messagebus_ruby_api 0.4.10 → 1.0.0

data/README.rdoc

@@ -1,89 +1,65 @@
 = Messagebus Ruby API
-=Installation
+
+== Installation
+
   gem install messagebus_ruby_api
-= Examples
-Start by requiring MessagebusRubyApi:
-  require 'messagebus_ruby_api'
-== Create the Api Client with your API key
-  client = MessagebusRubyApi::Client.new("<INSERT_YOUR_API_KEY>")
-==Sending Emails
-=== Setting common fields for your emails
-  client.send_common_info={:fromEmail=>"from@example.com"}
-==== When not using an API template
-=====Required send_common_info fields
-  :fromEmail
-=====Optional send_common_info fields
-  :fromName, :tags,
-   :customHeaders
-==== When using an API template
-=====Required send_common_info fields
-  :templateKey
-=====Optional send_common_info field
-  None
-=== Adding messages to the send buffer
-  result=client.add_message({:toEmail=>"to@example.com"})
-If you get a result >0 you get back the number of messages waiting to get sent
-If you get a result = 0 that means the buffer was flushed and you can get results from client.return_status
-Note: you should read from client.return_status before adding more messages since client.return_status will get cleared during the next auto-flush
-==== When not using an API template
-=====Required message fields
-  :toEmail, :subject, :plaintextBody or :htmlBody
-=====Optional message fields
-  :tag, :toName,
-==== When using an API template
-=====Required message fields
-  :mergeFields={"%EMAIL"=>"to@example.com", "%KEY1%"="testing"}
-  Note: the merge fields entries chould contain the keys used in the template, but only the %EMAIL% is required
-=====Optional message fields
-  None
-=== Flushing the send buffer
-  client.flush
-Note: Flushing returns the status of the messages that were sent (see bellow). It also clears old values to client.return_status
-Warning: You always need to flush your buffer when you are done adding messages to be sent or if you want to send messages with a different common_info (failure to do so could result in unsent messages getting lost or old messages getting sent with your new common_info
-=== Checking on message ids sent
-  client.return_status
-Status messages will be in the following form:
-  {
-      "statusMessage" => "OK",
-      "successCount" => 2,
-      "failureCount" => 0,
-      "results" => [
-            {
-          "status" => 200,
-          "messageId" => "e460d7f0-908e-012e-80b4-58b035f30fd1"
-            },
-            {
-          "status" => 200,
-          "messageId" => "e460d7f0-908e-012e-80b4-58b035f30fd2"
-            }
-      ]
-    }
-If there are failures you will get 400 or 500 status codes as well as error messages
-==Mailing List Management
-Calls take a mailing list key which can be found on the mailing list management page on messagebus.com
-Responses are of the form
-  {:statusMessage => "OK"}
-===Adding to a mailing list
-  merge_fields={"%EMAIL%"=>"a@example.com","%PARAM1%"=>"value 1"}
-  client.add_to_mailing_list(mailing_list_key, merge_fields)
-===Removing from a mailing list
-  client.remove_from_mailing_list(mailing_list_key, "a@example.com")
-==Viewing Error Reports
-  client.error_report
-results will be in the following form:
-  [
-    {:date=>"2011-08-16T21:19:20+00:00", :address=>"someguy@example.com", :errorCode=>"4.2.1"},
-    {:date=>"2011-08-17T21:19:20+00:00", :address=>"someguy@example.com", :errorCode=>"5.0.0"}
-  ]
-==Viewing Unsubscribes By Date
-  client.blocked_emails
-results will be in the following form:
-  [
-    {:email=>"test558_7283@example.com",:unsubscribe_time=>"2011-08-31T19:24:00+00:00","message_send_time"=>"2011-08-31T17:29:16+00:00","message_id"=>"testid"},
-    {:email=>"test558_7283@example.com",:unsubscribe_time=>"2011-08-31T19:24:00+00:00","message_send_time"=>"2011-08-31T17:29:16+00:00","message_id"=>"testid2"}
-  ]
-= Older Versions
+
+== Basic Use
+
+=== Start by requiring MessabusApi:
+
+    require 'messagebus_ruby_api'
+
+=== Then create an instance of the Messagebus class with your account information
+
+    client = MessagebusApi::Messagebus.new("<INSERT_YOUR_API_KEY>")
+
+=== Sending a single message
+
+==== Create Required Parameters
+
+      params = { :toEmail => 'apitest1@messagebus.com',
+        :toName => 'EmailUser',
+        :fromEmail => 'api@messagebus.com',
+        :fromName => 'API',
+        :subject => 'Unit Test Message',
+        :customHeaders => ["sender"=>"apitest1@messagebus.com"],
+        :plaintextBody => 'This message is only a test sent by the Ruby MessageBus client library.',
+        :htmlBody => "<html><body>This message is only a test sent by the Ruby MessageBus client library.</body></html>",
+        :tags => ['RUBY']
+      }
+
+==== Send the message
+
+     client.add_message(params)
+
+== Examples
+
+    The provided examples illustrate how to:
+    - send a single email message in the simplest way
+    - send one or more emails (where the email body is passed with the api call)
+    - send one or more templated emails (where a key referencing a previously stored email body is passed with the api call)
+    - create a mailing list, add and delete mailing list entries and list the existing mailing lists
+    - list recent email unsubscribes
+    - list recent email statistics
+    - list recent delivery errors
+
+== SSL Certificates
+
+    If you encounter SSL certificate problems, use the cacert_info() method to specify a
+    cacert.pem file (remember to specify the full path).
+
+    The curl site has an up to date version of the file:
+
+    http://curl.haxx.se/ca/cacert.pem
+
+== Older Versions
+
 If you are using the old api with the text OK:<UUID> responses, please be sure to get the 'v1' branch
 If you are using the old api with the 'body' parameter (instead of the new 'plaintextBody' and 'htmlBody' parameters), please be sure to get the 'v0' branch
-= More info
-Contact MessageBus if you have questions or problems (https://www.messagebus.com/contact)
+
+== Tests
+  To run the tests, issue the following command from the root of the project:
+  bundle exec rspec spec/messagebus_ruby_api/client_spec.rb
+== More info
+  Contact MessageBus if you have questions or problems (https://www.messagebus.com/contact)

data/lib/messagebus_ruby_api/errors.rb

@@ -1,4 +1,4 @@
-module MessagebusRubyApi
+module MessagebusApi
 
   class APIParameterError < StandardError
     def initialize(problematic_parameter="")
@@ -9,6 +9,9 @@ module MessagebusRubyApi
   class BadAPIKeyError < StandardError
   end
 
+  class MissingFileError <StandardError
+  end
+
   class RemoteServerError < StandardError
     attr_reader :result
     def initialize(message, result={})

data/lib/messagebus_ruby_api/messagebus.rb

@@ -0,0 +1,296 @@
+module MessagebusApi
+  DEFAULT_API_ENDPOINT_STRING = 'https://api.messagebus.com'
+
+  class Messagebus
+    TEMPLATE = 'template'
+    EMAIL= 'email'
+
+    attr_writer :send_common_info
+
+    def initialize(api_key)
+      @api_key = api_key
+
+      @http = http_connection(DEFAULT_API_ENDPOINT_STRING)
+      @user_agent = "MessagebusAPI:#{MessagebusApi::VERSION}-Ruby:#{RUBY_VERSION}"
+
+      @msg_buffer_size = 20
+      @msg_buffer = []
+      @msg_type = nil
+      @msg_buffer_flushed = false
+      @send_common_info = {}
+      @results = base_response_params
+      @rest_endpoints = define_rest_endpoints
+      @rest_http_errors = define_rest_http_errors
+    end
+
+    def results
+      @results
+    end
+
+    def message_buffer_size=(size)
+      @msg_buffer_size = size if (size >= 1 && size <= 100)
+    end
+
+    def message_buffer_size
+      @msg_buffer_size
+    end
+
+    def flushed?
+      @msg_buffer_flushed
+    end
+
+    def api_version
+      make_api_get_call(@rest_endpoints[:version])
+    end
+
+    def add_message(params, flush_buffer = false)
+      if params.key?(:templateKey)
+        add_template_message(params)
+      else
+        add_email_message(params)
+      end
+
+      @msg_buffer_flushed = false
+      if flush_buffer || @msg_buffer.size >= @msg_buffer_size
+        flush
+      end
+      return
+    end
+
+    def flush
+      if (@msg_buffer.size==0)
+        @results=@empty_send_results
+        return
+      end
+
+      if @msg_type == TEMPLATE
+        endpoint = @rest_endpoints[:templates_send]
+      else
+        endpoint = @rest_endpoints[:emails_send]
+      end
+
+      json = json_message_from_list(@msg_buffer)
+      @results=make_api_post_call(endpoint, json)
+      @msg_buffer.clear
+      @msg_buffer_flushed = true
+      return
+    end
+
+    def mailing_lists
+      make_api_get_call(@rest_endpoints[:mailing_lists])
+    end
+
+    def create_mailing_lists(list_name, merge_field_keys)
+      json = {:name => list_name, :mergeFieldKeys => merge_field_keys}.to_json
+      @results = make_api_post_call(@rest_endpoints[:mailing_lists], json)
+      @results
+    end
+
+    def delete_mailing_list_entry(mailing_list_key, email)
+      path = @rest_endpoints[:mailing_lists_entry_email].gsub("%KEY%", mailing_list_key).gsub("%EMAIL%", email)
+      @results = make_api_delete_call(path)
+      @results
+    end
+
+    def add_mailing_list_entry(mailing_list_key, merge_fields)
+      path = @rest_endpoints[:mailing_lists_entries].gsub("%KEY%", mailing_list_key)
+      json = {:mergeFields => merge_fields}.to_json
+      @results = make_api_post_call(path, json)
+      @results
+    end
+
+    def unsubscribes(start_date = '', end_date = '')
+      end_date = set_date(end_date, 0)
+      start_date = set_date(start_date, 7)
+      path = "#{@rest_endpoints[:unsubscribes]}?#{date_range(start_date, end_date)}"
+      @results = make_api_get_call(path)
+      @results
+    end
+
+    def delivery_errors(start_date = '', end_date = '')
+      end_date = set_date(end_date, 0)
+      start_date = set_date(start_date, 1)
+      path = "#{@rest_endpoints[:delivery_errors]}?#{date_range(start_date, end_date)}"
+      @results = make_api_get_call(path)
+      @results
+    end
+
+    def stats(start_date = '', end_date = '', tag = '')
+      end_date = set_date(end_date, 0)
+      start_date = set_date(start_date, 30)
+      path = "#{@rest_endpoints[:stats]}?#{date_range(start_date, end_date)}&tag=#{tag}"
+      @results = make_api_get_call(path)
+      @results
+    end
+
+    def cacert_info(cert_file)
+      @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      if !File.exists?(cert_file)
+        raise MessagebusApi::MissingFileError.new("Unable to read file #{cert_file}")
+      end
+      @http.ca_file = File.join(cert_file)
+    end
+
+    private
+
+    def http_connection(endpoint_url_string)
+      endpoint_url = URI.parse(endpoint_url_string)
+      http = Net::HTTP.new(endpoint_url.host, endpoint_url.port)
+      http.use_ssl = true
+      http
+    end
+
+    def common_http_headers
+      {'User-Agent' => @user_agent, 'X-MessageBus-Key' => @api_key}
+    end
+
+    def rest_post_headers
+      {"Content-Type" => "application/json; charset=utf-8"}
+    end
+
+    def add_email_message(params)
+      @msg_type = EMAIL if @msg_type == nil
+      @msg_buffer << base_message_params.merge!(params)
+
+    end
+
+    def add_template_message(params)
+      @msg_type = TEMPLATE if @msg_type == nil
+      @msg_buffer << base_template_params.merge!(params)
+    end
+
+    def date_range(start_date, end_date)
+      "startDate=#{start_date}&endDate=#{end_date}"
+    end
+
+    def set_date(date_string, days_ago)
+      if date_string.length == 0
+        return date_str_for_time_range(days_ago)
+      end
+      date_string
+    end
+
+    def date_str_for_time_range(days_ago)
+      (Time.now.utc - (days_ago*86400)).strftime("%Y-%m-%d")
+    end
+
+    def json_message_from_list(messages)
+      {:messages => messages}.to_json
+    end
+
+    def make_api_post_call(path, data)
+      headers = common_http_headers.merge(rest_post_headers)
+      response = @http.request_post(path, data, headers)
+      check_response(response)
+    end
+
+    def make_api_get_call(path)
+      headers = common_http_headers
+      response = @http.request_get(path, headers)
+      check_response(response)
+    end
+
+    def make_api_delete_call(path)
+      headers = common_http_headers
+      response = @http.delete(path, headers)
+      check_response(response)
+    end
+
+    def check_response(response, symbolize_names=true)
+      case response
+        when Net::HTTPSuccess
+          begin
+            return JSON.parse(response.body, :symbolize_names => symbolize_names)
+          rescue JSON::ParserError => e
+            raise MessagebusApi::RemoteServerError.new("JSON parsing error.  Response started with #{response.body.slice(0..9)}")
+          end
+        when Net::HTTPClientError, Net::HTTPServerError
+          if (response.body && response.body.size > 0)
+            result = begin
+              JSON.parse(response.body, :symbolize_names => symbolize_names)
+            rescue JSON::ParserError
+              nil
+            end
+            raise MessagebusApi::RemoteServerError.new("#{response.code.to_s}:#{rest_http_error_message(response.code.to_s)}")
+          else
+            raise MessagebusApi::RemoteServerError.new("#{response.code.to_s}:#{rest_http_error_message(response.code.to_s)}")
+          end
+        else
+          raise "Unexpected HTTP Response: #{response.class.name}"
+      end
+      raise "Could not determine response"
+    end
+
+    def rest_http_error?(status_code)
+      @rest_http_errors.key?(status_code)
+    end
+
+    def rest_http_error_message(status_code)
+      message = "Unknown Error Code"
+      message = @rest_http_errors[status_code] if rest_http_error?(status_code)
+      message
+    end
+
+    def define_rest_endpoints
+      {
+        :emails_send => "/api/v3/emails/send",
+        :templates_send => "/api/v3/templates/send",
+        :stats => "/api/v3/stats",
+        :delivery_errors => "/api/v3/delivery_errors",
+        :unsubscribes => "/api/v3/unsubscribes",
+        :mailing_lists => "/api/v3/mailing_lists",
+        :mailing_lists_entries => "/api/v3/mailing_list/%KEY%/entries",
+        :mailing_lists_entry_email => "/api/v3/mailing_list/%KEY%/entry/%EMAIL%",
+        :version => "/api/version"
+      }
+    end
+
+    def define_rest_http_errors
+      {
+        "400" => "Invalid Request",
+        "401" => "Unauthorized-Missing API Key",
+        "403" => "Unauthorized-Invalid API Key",
+        "404" => "Incorrect URL",
+        "405" => "Method not allowed",
+        "406" => "Format not acceptable",
+        "408" => "Request Timeout",
+        "409" => "Conflict",
+        "410" => "Object missing or deleted",
+        "413" => "Too many messages in request",
+        "415" => "POST JSON data invalid",
+        "422" => "Unprocessable Entity",
+        "500" => "Internal Server Error",
+        "501" => "Not Implemented",
+        "503" => "Service Unavailable",
+        "507" => "Insufficient Storage"
+      }
+    end
+
+    def base_response_params
+      {:statusCode => 0,
+       :statusMessage => "",
+       :statusTime => "1970-01-01T00:00:00.000Z"}
+    end
+
+    def base_message_params
+      {:toEmail => '',
+       :fromEmail => '',
+       :subject => '',
+       :toName => '',
+       :fromName => '',
+       :plaintextBody => '',
+       :htmlBody => '',
+       :customHeaders => {},
+       :tags => [] }
+    end
+
+    def base_template_params
+      {:toEmail => '',
+       :toName => '',
+       :templateKey => '',
+       :mergeFields => {},
+       :customHeaders => {} }
+    end
+
+  end
+end

data/lib/messagebus_ruby_api/version.rb

@@ -1,3 +1,3 @@
-module MessagebusRubyApi
-  VERSION = "0.4.10"
+module MessagebusApi
+  VERSION = "1.0.0"
 end

data/lib/messagebus_ruby_api.rb

@@ -5,5 +5,5 @@ require 'uri'
 require 'cgi'
 
 require "#{dir}/messagebus_ruby_api/errors"
-require "#{dir}/messagebus_ruby_api/client"
+require "#{dir}/messagebus_ruby_api/messagebus"
 require "#{dir}/messagebus_ruby_api/version"

data/spec/messagebus_ruby_api/cacert.pem

@@ -0,0 +1 @@
+# THIS IS ONLY FOR TESTING

data/spec/messagebus_ruby_api/messagebus_spec.rb

@@ -0,0 +1,286 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/../spec_helper"
+
+describe MessagebusApi::Messagebus do
+  attr_reader :client, :api_key, :required_params
+
+  def default_message_params
+    { :toEmail => 'apitest1@messagebus.com',
+      :toName => 'EmailUser',
+      :fromEmail => 'api@messagebus.com',
+      :fromName => 'API',
+      :subject => 'Unit Test Message',
+      :customHeaders => ["sender"=>"apitest1@messagebus.com"],
+      :plaintextBody => 'This message is only a test sent by the Ruby MessageBus client library.',
+      :htmlBody => "<html><body>This message is only a test sent by the Ruby MessageBus client library.</body></html>",
+      :tags => ['RUBY', 'Unit Test Ruby']
+    }
+  end
+
+  def default_template_message_params
+    { :toEmail => 'apitest1@messagebus.com',
+      :toName => 'John Smith',
+      :templateKey => '66f6181bcb4cff4cd38fbc804a036db6',
+      :customHeaders => ["reply-to"=>"apitest1@messagebus.com"],
+      :mergeFields => ["%NAME%" => "John"]
+    }
+  end
+
+  def create_success_result(num_result)
+    list=[]
+    num_result.times do
+      list << @success_message
+    end
+    
+    success_result = {
+      "statusMessage" => "OK",
+      "successCount" => num_result,
+      "failureCount" => 0,
+      "results" => list
+    }
+    success_result
+  end
+
+  def create_results_array
+    results = {
+        "statusMessage" => "OK",
+        "results" => []
+    }
+    results
+  end
+
+  def json_parse(data)
+     JSON.parse(data, :symbolize_names => true)
+  end
+
+  before do
+    FakeWeb.allow_net_connect = false
+
+    @api_key = "7215ee9c7d9dc229d2921a40e899ec5f"
+    @client = MessagebusApi::Messagebus.new(@api_key)
+    @success_message={
+      "status" => 200,
+      "messageId" => "abcdefghijklmnopqrstuvwxyz012345"
+    }
+    @simple_success_result = create_success_result(1)
+  end
+
+  describe "messagebus object set up correctly" do
+    it "has correct headers set for api calls" do
+      client = MessagebusApi::Messagebus.new(@api_key)
+    end
+  end
+
+  describe "add cacert file to http communitcations" do
+    it "raises error if cert file does not exist" do
+      client = MessagebusApi::Messagebus.new(@api_key)
+      cert_file_path = File.join(File.dirname(__FILE__), "nofile.pem")
+      expect do
+        client.cacert_info(cert_file_path)
+      end.should raise_error
+    end
+
+    it "accepts a cert file that exists" do
+      client = MessagebusApi::Messagebus.new(@api_key)
+      cert_file_path = File.join(File.dirname(__FILE__), "cacert.pem")
+      expect do
+        client.cacert_info(cert_file_path)
+      end.should_not raise_error
+    end
+  end
+
+  describe "#add_message" do
+    it "buffered send that adds to empty buffer" do
+      client.add_message(default_message_params)
+      client.flushed?.should be_false
+    end
+
+    it "buffered send that adds to empty buffer and sends with flush_buffer flag" do
+      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v3/emails/send", :body => json_valid_send)
+      client.add_message(default_message_params, true)
+      client.flushed?.should be_true
+    end
+
+    it "should have user-agent and x-messagebus-key set in request headers" do
+      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v3/emails/send", :body => json_valid_send)
+      client.add_message(default_message_params, true)
+      client.flushed?.should be_true
+
+      FakeWeb.last_request.get_fields("X-MessageBus-Key").should_not be_nil
+      FakeWeb.last_request.get_fields("User-Agent").should_not be_nil
+      FakeWeb.last_request.get_fields("Content-Type").should_not be_nil
+    end
+
+    it "buffered send that adds to a buffer and auto-flushes" do
+      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v3/emails/send", :body => create_success_result(client.message_buffer_size).to_json)
+      (client.message_buffer_size-1).times do |idx|
+        client.add_message(default_message_params)
+        client.flushed?.should be_false
+      end
+      client.add_message(default_message_params)
+      client.flushed?.should be_true
+      client.results[:results].size.should == client.message_buffer_size
+    end
+
+    it "buffered send that adds templates to a buffer and auto-flushes" do
+      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v3/templates/send", :body => create_success_result(client.message_buffer_size).to_json)
+      (client.message_buffer_size-1).times do |idx|
+        client.add_message(default_template_message_params)
+        client.flushed?.should be_false
+      end
+      client.add_message(default_template_message_params)
+      client.flushed?.should be_true
+      client.results[:results].size.should == client.message_buffer_size
+    end
+  end
+
+  describe "#flush" do
+    it "flush called on empty buffer" do
+      client.flush
+      client.flushed?.should be_false
+    end
+
+    it "flush called on partially filled buffer" do
+      message_count = 9
+      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v3/emails/send", :body => create_success_result(message_count).to_json)
+      (message_count).times do |idx|
+        client.add_message(default_message_params)
+        client.flushed?.should be_false
+      end
+      client.flush
+      client.flushed?.should be_true
+      client.results[:results].size.should == message_count
+    end
+  end
+
+  describe "#message_buffer_size=" do
+    it "can set the buffer size" do
+      client.message_buffer_size=(10)
+      client.message_buffer_size.should == 10
+    end
+
+    it "cannot set an invalid buffer size" do
+      default_buffer_size = 20
+      client.message_buffer_size=(-1)
+      client.message_buffer_size.should == default_buffer_size
+
+      client.message_buffer_size=(0)
+      client.message_buffer_size.should == default_buffer_size
+
+      client.message_buffer_size=(101)
+      client.message_buffer_size.should == default_buffer_size
+
+      client.message_buffer_size=(1)
+      client.message_buffer_size.should == 1
+
+      client.message_buffer_size=(100)
+      client.message_buffer_size.should == 100
+    end
+  end
+
+  describe "#delivery_errors" do
+    it "request delivery errors list" do
+
+      start_date_str="2011-01-01"
+      end_date_str="2011-01-02"
+
+      FakeWeb.register_uri(:get, "https://api.messagebus.com/api/v3/delivery_errors?startDate=#{start_date_str}&endDate=#{end_date_str}", :body => json_delivery_errors)
+      expect do
+        response = client.delivery_errors(start_date_str, end_date_str)
+        FakeWeb.last_request.body.should be_nil
+        response.should == json_parse(json_delivery_errors)
+      end.should_not raise_error
+    end
+  end
+
+  describe "#unsubscribes" do
+    it "request blocked emails list" do
+
+      start_date_str="2011-01-01T04:30:00+00:00"
+      end_date_str="2011-01-02T04:30:00+00:00"
+
+      expected_request="https://api.messagebus.com/api/v3/unsubscribes?startDate=#{URI.escape(start_date_str)}&endDate=#{URI.escape(end_date_str)}"
+
+      FakeWeb.register_uri(:get, expected_request, :body => json_unsubscribes)
+      expect do
+        response = client.unsubscribes(start_date_str, end_date_str)
+        FakeWeb.last_request.body.should be_nil
+        response.should == json_parse(json_unsubscribes)
+      end.should_not raise_error
+    end
+  end
+
+  describe "#delete_mailing_list_entry" do
+    it "remove from mailing list" do
+      mailing_list_key="test_key"
+      to_email="test@example.com"
+
+      expected_request="https://api.messagebus.com/api/v3/mailing_list/test_key/entry/test@example.com"
+
+      FakeWeb.register_uri(:delete, expected_request, :body => json_response_200)
+      expect do
+        response = client.delete_mailing_list_entry(mailing_list_key, to_email)
+        FakeWeb.last_request.body.should be_nil
+        response[:statusCode].should == 200
+      end.should_not raise_error
+
+    end
+  end
+
+  describe "#add_mailing_list_entry" do
+    it "add to mailing list" do
+      mailing_list_key="test_key"
+      merge_fields={"%EMAIL%"=>"test@example.com", "%PARAM1%"=>"test value"}
+      expected_request="https://api.messagebus.com/api/v3/mailing_list/test_key/entries"
+
+      FakeWeb.register_uri(:post, expected_request, :body => json_response_200)
+      expect do
+        response = client.add_mailing_list_entry(mailing_list_key, merge_fields)
+        FakeWeb.last_request.body.should =~ /mergeField/
+        response[:statusCode].should == 200
+      end.should_not raise_error
+
+    end
+  end
+
+  describe "#mailing_lists" do
+    it "get mailing lists" do
+      expected_request="https://api.messagebus.com/api/v3/mailing_lists"
+
+      FakeWeb.register_uri(:get, expected_request, :body => json_mailing_lists)
+      expect do
+        response = client.mailing_lists
+        response.should == json_parse(json_mailing_lists)
+      end.should_not raise_error
+    end
+  end
+
+  describe "#create_mailing_lists" do
+    it "create a new mailing list" do
+      expected_request="https://api.messagebus.com/api/v3/mailing_lists"
+
+      FakeWeb.register_uri(:post, expected_request, :body => json_mailing_list_create)
+      expect do
+        response = client.create_mailing_lists("Test List", ["%EMAIL%","%SOME_TOKEN%"])
+        response.should == json_parse(json_mailing_list_create)
+      end.should_not raise_error
+    end
+  end
+
+  describe "#stats" do
+    it "stats" do
+      start_date_str="2011-01-01"
+      end_date_str="2011-01-02"
+
+      expected_request="https://api.messagebus.com/api/v3/stats?startDate=#{start_date_str}&endDate=#{end_date_str}&tag="
+
+      FakeWeb.register_uri(:get, expected_request, :body => json_stats)
+      expect do
+        response = client.stats(start_date_str, end_date_str)
+        response.should == json_parse(json_stats)
+      end.should_not raise_error
+    end
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -7,3 +7,74 @@ require 'json'
 
 require "#{dir}/spec_core_extensions"
 require "#{dir}/../lib/messagebus_ruby_api"
+
+
+def json_valid_send
+  json = <<JAVASCRIPT
+{"statusCode":202,"statusMessage":"OK","statusTime":"2011-10-10T21:32:14.195Z","successCount":1,"failureCount":0,"results":[{"toEmail":"apitest1@messagebus.com","messageId":"51efcf00f38711e0a93640405cc99fee","messageStatus":0}]}
+JAVASCRIPT
+  json
+end
+
+def json_incomplete_results
+  json = <<JAVASCRIPT
+{"statusCode":202}
+JAVASCRIPT
+  json
+end
+
+def json_invalid_results
+  json = <<JAVASCRIPT
+GARBAGE_JSON
+JAVASCRIPT
+  json
+end
+
+def json_mailing_lists
+  json = <<JAVASCRIPT
+{"statusCode":200,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z","results":[{"name":"list_1","key":"51efcf00f38711e0a93640405cc99fee"}]}
+JAVASCRIPT
+  json
+end
+
+def json_mailing_list_create
+  json = <<JAVASCRIPT
+{"statusCode":201,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z","key":"51efcf00f38711e0a93640405cc99fee"}
+JAVASCRIPT
+  json
+end
+
+def json_unsubscribes
+  json = <<JAVASCRIPT
+{"statusCode":200,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z","results":[{"toEmail":"joe@example.com","time":"2011-10-10T21:32:14.195Z"}]}
+JAVASCRIPT
+  json
+end
+
+def json_delivery_errors
+  json = <<JAVASCRIPT
+{"statusCode":200,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z","results":[{"toEmail":"joe@example.com", "messageId":"62cf5460b7b0012e8cb440406818e8c7","time":"2011-10-10T21:32:14.195Z","DSNCode":"5.1.1"}]}
+JAVASCRIPT
+  json
+end
+
+def json_stats
+  json = <<JAVASCRIPT
+{"statusCode":200,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z","results":[{"date":"2011-09-01", "sent":10,"errors":2,"opens":3,"uniqueOpens":2,"clicks":0}]}
+JAVASCRIPT
+  json
+end
+
+def json_response_201
+  json = <<JAVASCRIPT
+{"statusCode":201,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z"}
+JAVASCRIPT
+  json
+end
+
+def json_response_200
+  json = <<JAVASCRIPT
+{"statusCode":200,"statusMessage":"","statusTime":"2011-10-10T21:32:14.195Z"}
+JAVASCRIPT
+  json
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: messagebus_ruby_api
 version: !ruby/object:Gem::Version
-  version: 0.4.10
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-08 00:00:00.000000000Z
+date: 2011-11-23 00:00:00.000000000Z
 dependencies: []
 description: ! 'Allows you to use the Messagebus API '
 email:
@@ -18,11 +18,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/messagebus_ruby_api/client.rb
 - lib/messagebus_ruby_api/errors.rb
+- lib/messagebus_ruby_api/messagebus.rb
 - lib/messagebus_ruby_api/version.rb
 - lib/messagebus_ruby_api.rb
-- spec/messagebus_ruby_api/client_spec.rb
+- spec/messagebus_ruby_api/cacert.pem
+- spec/messagebus_ruby_api/messagebus_spec.rb
 - spec/spec_core_extensions.rb
 - spec/spec_helper.rb
 - README.rdoc
@@ -49,11 +50,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: messagebus_ruby_api
-rubygems_version: 1.8.8
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Send email through Messagebus service
 test_files:
-- spec/messagebus_ruby_api/client_spec.rb
+- spec/messagebus_ruby_api/cacert.pem
+- spec/messagebus_ruby_api/messagebus_spec.rb
 - spec/spec_core_extensions.rb
 - spec/spec_helper.rb

data/lib/messagebus_ruby_api/client.rb

@@ -1,210 +0,0 @@
-module MessagebusRubyApi
-  DEFAULT_API_ENDPOINT_STRING = 'https://api.messagebus.com:443'
-
-  class Client
-    attr_reader :api_key, :endpoint_url, :http
-    attr_reader :email_buffer, :send_return_status, :email_buffer_size, :user_agent
-    attr_writer :send_common_info
-    @empty_send_results=nil
-
-    def initialize(api_key, endpoint_url_string = DEFAULT_API_ENDPOINT_STRING)
-      @api_key = verified_reasonable_api_key(api_key)
-      @endpoint_url = URI.parse(endpoint_url_string)
-      @end_point_v2_base_path="/api/v2/"
-      @http = Net::HTTP.new(@endpoint_url.host, @endpoint_url.port)
-      @http.use_ssl = true
-      @user_agent = "MessagebusAPI:#{MessagebusRubyApi::VERSION}-Ruby:#{RUBY_VERSION}"
-
-      @email_buffer_size=20
-      @email_buffer=[]
-      @empty_send_results= {
-        :statusMessage => "",
-        :successCount => 0,
-        :failureCount => 0,
-        :results => []
-      }
-      @send_return_status=@empty_send_results
-      @send_common_info={}
-    end
-
-    def add_message(email_options)
-      @email_buffer<<email_options
-      if (@email_buffer.size >= @email_buffer_size)
-        flush
-        return 0
-      else
-        return @email_buffer.size
-      end
-    end
-
-    def flush
-      if (@email_buffer.size==0)
-        @send_return_status=@empty_send_results
-        return
-      end
-      @send_return_status=buffered_send(@email_buffer, @send_common_info)
-      @email_buffer.clear
-      @send_return_status
-    end
-
-    def add_mailing_list_entry(mailing_list_key, merge_fields)
-      request = create_api_post_request("#{@end_point_v2_base_path}mailing_list_entry/add_entry")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      json = {
-        "apiKey" => @api_key,
-        "mailingListKey" => mailing_list_key,
-        "mergeFields" => merge_fields
-      }.to_json
-      request.form_data={'json' => json}
-      make_api_call(request)
-    end
-
-    def remove_mailing_list_entry(mailing_list_key, to_email)
-      request = create_api_delete_request("#{@end_point_v2_base_path}mailing_list_entry")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      json = {
-        "apiKey" => @api_key,
-        "mailingListKey" => mailing_list_key,
-        "email" => to_email
-      }.to_json
-      request.form_data={'json' => json}
-      make_api_call(request)
-    end
-
-    def get_mailing_lists
-      request=create_api_get_request("#{@end_point_v2_base_path}mailingLists?apiKey=#{@api_key}")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      make_api_call(request)
-    end
-
-    def get_error_report
-      request=create_api_get_request("#{@end_point_v2_base_path}emails/error_report?apiKey=#{@api_key}")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      make_api_call(request)
-    end
-
-    def get_unsubscribe_results(start_date, end_date=nil)
-      start_dt = DateTime.parse(start_date)
-      end_dt = DateTime.parse(end_date)
-      additional_params="startDate=#{URI.escape("#{start_dt}")}"
-      unless (end_date.nil?)
-        additional_params+="&endDate=#{URI.escape("#{end_dt}")}"
-      end
-      request=create_api_get_request("#{@end_point_v2_base_path}blocked_emails?apiKey=#{@api_key}&#{additional_params}")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      make_api_call(request)
-    end
-
-    def basic_auth_credentials=(credentials)
-      @credentials = credentials
-    end
-
-    def buffered_send(message_list, common_options)
-      if (message_list.length==0)
-        return {
-          :statusMessage => "OK",
-          :successCount => 0,
-          :failureCount => 0}
-      end
-      request = create_api_post_request("#{@end_point_v2_base_path}emails/send")
-      request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-      request.form_data={'json' => make_json_message_from_list(message_list, common_options)}
-      make_api_call(request)
-    end
-
-    private
-
-    def create_api_post_request(path)
-      Net::HTTP::Post.new(path, {'User-Agent' => user_agent})
-    end
-
-    def create_api_get_request(path)
-      Net::HTTP::Get.new(path, {'User-Agent' => user_agent})
-    end
-
-    def create_api_delete_request(path)
-      Net::HTTP::Delete.new(path, {'User-Agent' => user_agent})
-    end
-
-    def check_priority(priority)
-      raise APIParameterError.new(":priority can only be an integer between 1 and 5, not \"#{priority}\"") unless priority.is_a?(Integer) && (1..5).include?(priority)
-      priority.to_s
-    end
-
-    def verified_reasonable_api_key(api_key)
-      raise BadAPIKeyError unless api_key.match(/^[a-zA-Z0-9]{32}$/)
-      api_key
-    end
-
-    def validate(params)
-      raise APIParameterError.new("toEmail") unless params[:toEmail]
-      raise APIParameterError.new("fromEmail") unless params[:fromEmail]
-      raise APIParameterError.new("subject") unless params[:subject]
-      raise APIParameterError.new("plaintextBody or htmlBody") unless params[:plaintextBody] || params[:htmlBody]
-      params[:priority] = check_priority(params[:priority]) unless params[:priority].nil?
-    end
-
-    def make_json_message(options)
-      map={}
-      map["toEmail"]=options[:toEmail] if (options.has_key? :toEmail)
-      map["toName"]=options[:toName] if (options.has_key? :toName)
-      map["subject"]=options[:subject] if (options.has_key? :subject)
-      map["plaintextBody"]=options[:plaintextBody] if (options.has_key? :plaintextBody)
-      map["htmlBody"]=options[:htmlBody] if (options.has_key? :htmlBody)
-      map["fromName"]=options[:fromName] if (options.has_key? :fromName)
-      map["tag"]=options[:tag] if (options.has_key? :tag)
-      map["mergeFields"]=options[:mergeFields] if (options.has_key? :mergeFields)
-      map
-    end
-
-    def make_json_message_from_list(option_list, common_options)
-      message_list=[]
-      option_list.each do |list_item|
-        message_list<<make_json_message(list_item)
-      end
-      json = {
-        "apiKey" => @api_key,
-        "messageCount" => message_list.length,
-        "messages" => message_list
-      }
-      if (common_options!=nil)
-        json["fromEmail"]=common_options[:fromEmail] if (common_options.has_key? :fromEmail)
-        json["fromName"]=common_options[:fromName] if (common_options.has_key? :fromName)
-        json["tags"]=common_options[:tags] if (common_options.has_key? :tags)
-        json["customHeaders"]=common_options[:customHeaders] if (common_options.has_key? :customHeaders)
-        json["templateKey"]=common_options[:templateKey] if (common_options.has_key? :templateKey)
-      end
-
-      json.reject { |k, v| v == nil }.to_json
-    end
-
-    def make_api_call(request, symbolize_names=true)
-      response = @http.start do |http|
-        request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
-        http.request(request)
-      end
-      case response
-        when Net::HTTPSuccess
-          begin
-            return JSON.parse(response.body, :symbolize_names => symbolize_names)
-          rescue JSON::ParserError => e
-            raise MessagebusRubyApi::RemoteServerError.new("Remote server returned unrecognized response: #{e.message}")
-          end
-        when Net::HTTPClientError, Net::HTTPServerError
-          if (response.body && response.body.size > 0)
-            result = begin
-              JSON.parse(response.body, :symbolize_names => symbolize_names)
-            rescue JSON::ParserError
-              nil
-            end
-            raise MessagebusRubyApi::RemoteServerError.new("Remote Server Returned: #{response.code.to_s}.  #{result[:statusMessage] if result}", result)
-          else
-            raise MessagebusRubyApi::RemoteServerError.new("Remote Server Returned: #{response.code.to_s}")
-          end
-        else
-          raise "Unexpected HTTP Response: #{response.class.name}"
-      end
-      raise "Could not determine response"
-    end
-  end
-end

data/spec/messagebus_ruby_api/client_spec.rb

@@ -1,220 +0,0 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/../spec_helper"
-
-describe MessagebusRubyApi::Client do
-  attr_reader :client, :api_key, :required_params
-
-  def create_success_result(num_result)
-    list=[]
-    num_result.times do
-      list << @success_message
-    end
-    success_result = {
-      "statusMessage" => "OK",
-      "successCount" => 1,
-      "failureCount" => 0,
-      "results" => list
-    }
-    success_result
-  end
-
-  def create_results_array
-    results = {
-        "statusMessage" => "OK",
-        "results" => []
-    }
-    results
-  end
-
-  before do
-    FakeWeb.allow_net_connect = false
-
-    @api_key = "3"*32
-    @client = MessagebusRubyApi::Client.new(api_key)
-    @required_params = {:toEmail => "bob@example.com", :plaintextBody => "a nice ocean", :subject => "test subject"}
-    @success_message={
-      "status" => 200,
-      "messageId" => "e460d7f0-908e-012e-80b4-58b035f30fd1"
-    }
-    @simple_success_result = create_success_result(1)
-  end
-
-  describe "#bulk_send" do
-
-    before do
-      @common_options={:fromEmail => "bob@example.com", :customHeaders => {"customfield1"=>"custom value 1", "customfield2"=>"custom value 2"}}
-    end
-
-    describe "#add_message" do
-      it "buffered send that adds to empty buffer" do
-        client.send_common_info=@common_options
-        client.email_buffer.size.should == 0
-        client.add_message(required_params)
-        client.email_buffer.size.should == 1
-      end
-
-      it "buffered send that adds to a buffer and auto-flushes" do
-        FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v2/emails/send", :body => create_success_result(client.email_buffer_size).to_json)
-        client.send_common_info=@common_options
-        client.send_return_status[:results].size.should == 0
-        (client.email_buffer_size-1).times do |idx|
-          client.add_message(required_params).should == idx+1
-          client.send_return_status[:results].size.should == 0
-        end
-        client.add_message(required_params).should == 0
-        client.send_return_status[:results].size.should == client.email_buffer_size
-      end
-    end
-
-    describe "#flush" do
-      it "flush called on empty buffer" do
-        client.send_common_info=@common_options
-        client.send_return_status[:results].size.should == 0
-        client.flush
-        client.send_return_status[:results].size.should == 0
-      end
-      it "flush called on filled buffer" do
-        FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v2/emails/send", :body => create_success_result(10).to_json)
-        client.send_common_info=@common_options
-        10.times do
-          client.add_message(required_params)
-        end
-        client.flush
-        client.send_return_status[:results].size.should == 10
-      end
-    end
-
-    it "send an empty buffer" do
-      expect do
-        response = client.buffered_send([], @common_options)
-        response[:successCount].should == 0
-      end.should_not raise_error
-    end
-
-    it "send a single item buffer" do
-      buffer=[required_params]
-      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v2/emails/send", :body => @simple_success_result.to_json)
-      #expect do
-      response = client.buffered_send(buffer, @common_options)
-      FakeWeb.last_request.body.should =~ /json=/
-      response[:successCount].should == 1
-      #end.should_not raise_error
-    end
-
-    it "send a several item buffer" do
-      buffer=[required_params, required_params]
-      @success_result2 = {
-        "statusMessage" => "OK",
-        "successCount" => 2,
-        "failureCount" => 0,
-        "results" => [
-          {
-            "status" => 200,
-            "messageId" => "e460d7f0-908e-012e-80b4-58b035f30fd1"
-          },
-          {
-            "status" => 200,
-            "messageId" => "e460d7f0-908e-012e-80b4-58b035f30fd2"
-          }
-        ]}
-      FakeWeb.register_uri(:post, "https://api.messagebus.com/api/v2/emails/send", :body => @success_result2.to_json)
-      expect do
-        response = client.buffered_send(buffer, @common_options)
-        FakeWeb.last_request.body.should =~ /json=/
-        response[:successCount].should == 2
-      end.should_not raise_error
-    end
-  end
-
-  describe "#get_error_report" do
-    it "request error report" do
-
-      start_date_str="2011-01-01T04:30:00+00:00"
-      end_date_str="2011-01-02T04:30:00+00:00"
-
-      @success_result={
-        :reportSize=>2,
-        :results=>[
-          {:date => start_date_str, :address => "someguy@example.com", :errorCode => "4.2.1"},
-          {:date => end_date_str, :address => "someguy@example.com", :errorCode => "5.0.0"}
-        ]
-      }
-
-      FakeWeb.register_uri(:get, "https://api.messagebus.com/api/v2/emails/error_report?apiKey=#{@api_key}", :body => @success_result.to_json)
-      expect do
-        response = client.get_error_report
-        FakeWeb.last_request.body.should be_nil
-        response.should == @success_result
-      end.should_not raise_error
-    end
-  end
-
-  describe "#get_unsubscribe_results" do
-    it "request blocked emails list" do
-
-      start_date_str="2011-01-01T04:30:00+00:00"
-      end_date_str="2011-01-02T04:30:00+00:00"
-
-      @success_result=[
-        {:email=>"test1@example.com", :message_send_time=>"2011-01-01T03:02:00", :unsubscribe_time=>"2011-01-02T04:32:00", :message_id=>"testmessageid1"},
-        {:email=>"test2@example.com", :message_send_time=>"2011-01-01T02:02:00", :unsubscribe_time=>"2011-01-02T02:32:00", :message_id=>"testmessageid2"}
-      ]
-      expected_request="https://api.messagebus.com/api/v2/blocked_emails?apiKey=#{@api_key}&startDate=#{URI.escape(start_date_str)}&endDate=#{URI.escape(end_date_str)}"
-
-      FakeWeb.register_uri(:get, expected_request, :body => @success_result.to_json)
-      expect do
-        response = client.get_unsubscribe_results(start_date_str, end_date_str)
-        FakeWeb.last_request.body.should be_nil
-        response.should == @success_result
-      end.should_not raise_error
-    end
-  end
-
-  describe "#remove_mailing_list_entry" do
-    it "remove from mailing list" do
-      mailing_list_key="test_key"
-      to_email="test@example.com"
-
-      expected_request="https://api.messagebus.com/api/v2/mailing_list_entry"
-
-      FakeWeb.register_uri(:delete, expected_request, :body => {"statusMessage" => "OK"}.to_json)
-      expect do
-        response = client.remove_mailing_list_entry(mailing_list_key, to_email)
-        FakeWeb.last_request.body.should =~ /json=/
-        response.should == {:statusMessage => "OK"}
-        FakeWeb.last_request.body
-      end.should_not raise_error
-
-    end
-  end
-
-  describe "#add_mailing_list_entry" do
-    it "add to mailing list" do
-      mailing_list_key="test_key"
-      merge_fields={"%EMAIL%"=>"a@example.com", "%PARAM1%"=>"test value"}
-      expected_request="https://api.messagebus.com/api/v2/mailing_list_entry/add_entry"
-
-      FakeWeb.register_uri(:post, expected_request, :body => {"statusMessage" => "OK"}.to_json)
-      expect do
-        response = client.add_mailing_list_entry(mailing_list_key, merge_fields)
-        FakeWeb.last_request.body.should =~ /json=/
-        response.should == {:statusMessage => "OK"}
-      end.should_not raise_error
-
-    end
-  end
-
-  describe "#get_mailing_lists" do
-    it "get mailing lists" do
-      expected_request="https://api.messagebus.com/api/v2/mailingLists?apiKey=#{@api_key}"
-
-      FakeWeb.register_uri(:get, expected_request, :body => create_results_array.to_json)
-      expect do
-        response = client.get_mailing_lists
-        response.should == {:statusMessage => "OK", :results => []}
-      end.should_not raise_error
-    end
-  end
-
-end
-