messagebus_ruby_api 0.0.1 → 0.1.0

data/.gitignore

@@ -1 +1,2 @@
 .idea/*
+*.gem

data/.rvmrc

@@ -1 +1 @@
-rvm use ree-1.8.7-2010.02@messagebus_ruby_api
+rvm use ruby-1.9.2-p180@messagebus_ruby_api --create

data/Gemfile

@@ -1,7 +1,5 @@
 source "http://rubygems.org"
 
-
-
 group :test, :development do
   gem 'rspec', '2.5.0'
   gem 'rr', '1.0.2'

data/README.rdoc

@@ -0,0 +1,53 @@
+= Messagebus Ruby API
+
+== Installation
+
+  bundle 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>")
+
+
+=== Required Parameters
+
+    required_params = {
+      :subject => "e-mail subject",
+      :body => "This is the email body",
+      :fromEmail => "from@example.com",
+      :toEmail => "to@example.com"
+    }
+
+=== Optional Parameters
+
+    optional_params = {
+      :fromName => "From Name",
+      :toName => "To Name",
+      :tag => "tags separated by spaces"
+    }
+
+=== Sending an e-mail with the client
+
+    @params = {
+      :subject => "e-mail subject",
+      :body => "This is the email body",
+      :fromEmail => "from@example.com",
+      :toEmail => "to@example.com"
+    }
+
+    response = client.send_email(@params)
+    puts "API call failed" unless response.body =~ /^OK:(.*)$/
+
+
+== More info
+
+Contact MessageBus if you have questions or problems (https://www.messagebus.com/contact)
+
+

data/lib/messagebus_ruby_api.rb

@@ -2,6 +2,5 @@ require 'net/https'
 require 'uri'
 require 'cgi'
 
-require 'messagebus_ruby_api/core_extensions'
 require 'messagebus_ruby_api/errors'
 require 'messagebus_ruby_api/client'

data/lib/messagebus_ruby_api/client.rb

@@ -1,54 +1,70 @@
 module MessagebusRubyApi
-  API_ENDPOINT = URI.parse('https://api.messagebus.com:443')
+  DEFAULT_API_ENDPOINT_STRING = 'https://api.messagebus.com:443'
 
   class Client
-    attr_reader :api_key
+    attr_reader :api_key, :endpoint_url, :http
 
-    def initialize(api_key)
+    def initialize(api_key, endpoint_url_string = DEFAULT_API_ENDPOINT_STRING)
       @api_key = verified_reasonable_api_key(api_key)
-      @http = api_endpoint_http_connection
+      @endpoint_url = URI.parse(endpoint_url_string)
+      @http = api_endpoint_http_connection(endpoint_url)
       @http.use_ssl = true
     end
 
-    def api_endpoint_http_connection
-      Net::HTTP.new(API_ENDPOINT.host, API_ENDPOINT.port)
-    end
-
     def complete_url(options)
       params_string = to_param(check_params(options))
-      url = "/send?operation=sendEmail&#{params_string}"
+      url = "/send?operation=sendEmail&#{params_string}&apiKey=#{api_key}"
       url
     end
 
-    def api_request(options)
-      Net::HTTP::Post.new(complete_url(options)) #, {"User-Agent" => "messagebus.com Messagebus Ruby API v1"})
-    end
-
     def send_email(options)
       verify_required_params(options)
       response = @http.start do |http|
         request = api_request(options)
+        request.basic_auth(@credentials[:user], @credentials[:password]) if @credentials
         http.request(request)
       end
-
-      raise MessagebusRubyApi::UnknownError unless response.body.match(/^OK/)
-      response
+      case response
+        when Net::HTTPSuccess
+          return response
+        when Net::HTTPClientError, Net::HTTPServerError
+          if (response.body && response.body.size > 0)
+            raise MessagebusRubyApi::RemoteServerError.new(response.body)
+          else
+            raise MessagebusRubyApi::RemoteServerError.new("ERR:Remote Server Returned: #{response.code.to_s}")
+          end
+        else
+          raise "Unexpected HTTP Response: #{response.class.name}"
+      end
+      raise "Could not determine response"
     end
 
     def check_params(params)
-      params[:plain_text] = check_plain_text(params[:plain_text]) unless params[:plain_text].nil?
+      params[:plainText] = check_plain_text(params[:plainText]) unless params[:plainText].nil?
       params[:priority] = check_priority(params[:priority]) unless params[:priority].nil?
       params
     end
 
     def to_param(params)
-      params.map { |name, val| [name.to_s.camelize, val] }.sort.map { |param_name, param_value| "#{CGI.escape(param_name)}=#{CGI.escape(param_value)}" }.join("&")
+      params.map { |name, val| [name.to_s, val] }.sort.map { |param_name, param_value| "#{CGI.escape(param_name)}=#{CGI.escape(param_value)}" }.join("&")
+    end
+
+    def basic_auth_credentials=(credentials)
+      @credentials = credentials
     end
 
     private
 
+    def api_request(options)
+      Net::HTTP::Post.new(complete_url(options)) #, {"User-Agent" => "messagebus.com Messagebus Ruby API v1"})
+    end    
+
+    def api_endpoint_http_connection(endpoint_url)
+      Net::HTTP.new(endpoint_url.host, endpoint_url.port)
+    end
+
     def check_plain_text(plain_text)
-      raise APIParameterError.new(":plain_text can only be true or false, not \"#{plain_text}\" of type #{plain_text.class}") unless [true, false].include?(plain_text)
+      raise APIParameterError.new(":plainText can only be true or false, not \"#{plain_text}\" of type #{plain_text.class}") unless [true, false].include?(plain_text)
       plain_text ? "1" : "0"
     end
 
@@ -58,13 +74,13 @@ module MessagebusRubyApi
     end
 
     def verified_reasonable_api_key(api_key)
-      raise BadAPIKeyError unless api_key.match(/[a-zA-Z0-9]{20}/)
+      raise BadAPIKeyError unless api_key.match(/^[a-zA-Z0-9]{32}$/)
       api_key
     end
 
     def verify_required_params(params)
-      raise APIParameterError.new("to_email") unless params[:to_email]
-      raise APIParameterError.new("from_email") unless params[:from_email]
+      raise APIParameterError.new("toEmail") unless params[:toEmail]
+      raise APIParameterError.new("fromEmail") unless params[:fromEmail]
       raise APIParameterError.new("subject") unless params[:subject]
       raise APIParameterError.new("body") unless params[:body]
     end

data/lib/messagebus_ruby_api/errors.rb

@@ -6,10 +6,13 @@ module MessagebusRubyApi
     end
   end
 
-  class BadAPIKeyError < StandardError;
+  class BadAPIKeyError < StandardError
   end
 
-  class UnknownError < StandardError;
+  class RemoteServerError < StandardError
+    def initialize(message)
+      super
+    end
   end
   
 end

data/lib/messagebus_ruby_api/version.rb

@@ -1,3 +1,3 @@
 module MessagebusRubyApi
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/messagebus_ruby_api/client_spec.rb

@@ -7,10 +7,14 @@ describe MessagebusRubyApi::Client do
 
     @api_key = "3"*32
     @client = MessagebusRubyApi::Client.new(api_key)
-    @required_params = {:to_email => "bob@example.com", :from_email => "alice@example.com", :body => "a nice ocean", :subject => "test subject"}
+    @required_params = {:toEmail => "bob@example.com", :fromEmail => "alice@example.com", :body => "a nice ocean", :subject => "test subject"}
   end
 
   it "requires an api key" do
+    expect do
+      MessagebusRubyApi::Client.new("3"*32)
+    end.should_not raise_error(MessagebusRubyApi::BadAPIKeyError)
+
     expect do
       MessagebusRubyApi::Client.new("foo")
     end.should raise_error(MessagebusRubyApi::BadAPIKeyError)
@@ -20,6 +24,15 @@ describe MessagebusRubyApi::Client do
     client.api_key.should == api_key
   end
 
+  it "defaults the endpoint URL if one is not supplied" do
+    @client.endpoint_url.host.should =~ /api\.messagebus\.com/
+  end
+
+  it "talks to the supplied endpoint url" do
+    another_client = MessagebusRubyApi::Client.new(api_key, "http://localhost:8080")
+    another_client.endpoint_url.host.should =~ /localhost/
+  end
+
   describe "required parameters" do
     it "works when the minimum params are sent" do
       url_params = client.to_param(required_params)
@@ -31,12 +44,12 @@ describe MessagebusRubyApi::Client do
 
     it "raises errors when missing to_email param" do
       api_response = "ERR :Missing required paramater toEmail"
-      expect_api_errors(required_params.without(:to_email), api_response, "to_email")
+      expect_api_errors(required_params.without(:toEmail), api_response, "toEmail")
     end
 
     it "raises errors when missing from_email param" do
       api_response = "ERR:Missing required paramater fromEmail"
-      expect_api_errors(required_params.without(:from_email), api_response, "from_email")
+      expect_api_errors(required_params.without(:fromEmail), api_response, "fromEmail")
     end
 
     it "raises errors when missing subject param" do
@@ -52,11 +65,11 @@ describe MessagebusRubyApi::Client do
 
   describe "optional parameters" do
     it "allows to_name" do
-      expect_api_success(required_params.merge(:to_name => "Chuck Norris"))
+      expect_api_success(required_params.merge(:toName => "Chuck Norris"))
     end
 
     it "allows from_name" do
-      expect_api_success(required_params.merge(:from_name => "Sally Norris"))
+      expect_api_success(required_params.merge(:fromName => "Sally Norris"))
     end
 
     it "allows tag" do
@@ -84,30 +97,61 @@ describe MessagebusRubyApi::Client do
     end
 
     it "allows reply_to" do
-      expect_api_success(required_params.merge(:reply_to => "obiwan@example.com"))
+      expect_api_success(required_params.merge(:replyTo => "obiwan@example.com"))
     end
 
     it "allows unsubscribe_email" do
-      expect_api_success(required_params.merge(:unsubscribe_email => "unsubscribe@aol.com"))
+      expect_api_success(required_params.merge(:unsubscribeEmail => "unsubscribe@aol.com"))
     end
 
     it "allows unsubscribe_url" do
-      expect_api_success(required_params.merge(:unsubscribe_url => "http://foobar.com/unsubscribe"))
+      expect_api_success(required_params.merge(:unsubscribeUrl => "http://foobar.com/unsubscribe"))
     end
 
     it "allows plain_text" do
-      expect_api_success(required_params.merge(:plain_text => false))
-      expect_api_success(required_params.merge(:plain_text => true))
+      expect_api_success(required_params.merge(:plainText => false))
+      expect_api_success(required_params.merge(:plainText => true))
 
       expect do
-        client.send_email(required_params.merge(:plain_text => "omg not a boolean or nil"))
+        client.send_email(required_params.merge(:plainText => "omg not a boolean or nil"))
       end.should raise_error(MessagebusRubyApi::APIParameterError)
     end
   end
 
   describe "#to_param" do
-    it "camelizes param names and sorts them" do
-      client.to_param({:to_email => "bob@example.com", :from_email => "alex@example.com"}).should == "fromEmail=alex%40example.com&toEmail=bob%40example.com"
+    it "converts to param names and sorts them" do
+      client.to_param({:toEmail => "bob@example.com", :fromEmail => "alex@example.com"}).should == "fromEmail=alex%40example.com&toEmail=bob%40example.com"
+    end
+  end
+
+  describe "server errors" do
+    it "raises an error with the error status received by the server" do
+      url_params = client.to_param(required_params)
+      error_response_body = "ERR:Some meaningful remote error"
+      FakeWeb.register_uri(:post, api_url_from_params(url_params), status: [500, ""], :body => error_response_body)
+      expect do
+        client.send_email(required_params)
+      end.should raise_error(MessagebusRubyApi::RemoteServerError, error_response_body)
+    end
+
+    it "raises an error if the remote server returns a status other than 200 OK" do
+      url_params = client.to_param(required_params)
+      FakeWeb.register_uri(:post, api_url_from_params(url_params), :status => [404, "Not Found"], :body => "")
+      expect do
+        client.send_email(required_params)
+      end.should raise_error(MessagebusRubyApi::RemoteServerError, "ERR:Remote Server Returned: 404")
+    end
+  end
+
+  describe "#basic_auth_credentials=" do
+    it "uses basic auth with the supplied credentials" do
+      client.basic_auth_credentials = {:user => "user", :password => "pass"}
+      url_params = client.to_param(required_params)
+      FakeWeb.register_uri(:post, api_url_from_params(url_params), :body => "Unauthorized", :status => ["401", "Unauthorized"])
+      FakeWeb.register_uri(:post, "https://user:pass@api.messagebus.com/send?operation=sendEmail&apiKey=#{api_key}&#{url_params}", :body => "OK:OK")
+      expect do
+        client.send_email(required_params)
+      end.should_not raise_error
     end
   end
 end
@@ -131,5 +175,5 @@ def expect_api_errors(params, fake_response, expected_error_message="")
 end
 
 def api_url_from_params(url_param_string)
-  "https://api.messagebus.com/send?operation=sendEmail&#{url_param_string}"
+  "https://api.messagebus.com/send?operation=sendEmail&apiKey=#{api_key}&#{url_param_string}"
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: messagebus_ruby_api
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Messagebus dev team
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 -07:00
+date: 2011-06-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -34,10 +29,10 @@ files:
 - .rvmrc
 - Gemfile
 - Gemfile.lock
+- README.rdoc
 - Rakefile
 - lib/messagebus_ruby_api.rb
 - lib/messagebus_ruby_api/client.rb
-- lib/messagebus_ruby_api/core_extensions.rb
 - lib/messagebus_ruby_api/errors.rb
 - lib/messagebus_ruby_api/version.rb
 - messagebus.gemspec
@@ -58,23 +53,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: messagebus_ruby_api
-rubygems_version: 1.6.2
+rubygems_version: 1.6.1
 signing_key: 
 specification_version: 3
 summary: Send email through Messagebus service

data/lib/messagebus_ruby_api/core_extensions.rb

@@ -1,5 +0,0 @@
-class String
-  def camelize
-    self.split(/[^a-z0-9]/i).map(&:capitalize).join.tap { |string| string[0, 1] = string[0, 1].downcase }
-  end
-end