messagebus_ruby_apn_api 1.0.0

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use ruby-1.9.2-p180-patched@messagebus_ruby_api --create
+

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem 'activesupport'
+
+group :test, :development do
+  gem 'rspec', '2.5.0'
+  gem 'rr', '1.0.2'
+  gem 'fakeweb'
+end
+
+# Specify your gem's dependencies in messagebus.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,64 @@
+= Message Bus Ruby APN API
+
+== Installation
+
+  gem install messagebus_ruby_apn_api
+
+== Basic Use
+
+=== Start by requiring MessabusApi:
+
+    require 'messagebus_ruby_apn_api'
+
+=== Then create an instance of the Messagebus class with your account information
+
+    client = MessagebusApnApi::Messagebus.new("<INSERT_YOUR_API_KEY>")
+
+=== Sending a single notification
+
+==== Create Required Parameters
+
+      params = { :userName => 'apitest1@messagebus.com',
+        :alert => 'Hello push notification world.',
+        :platform => Messagebus::PLATFORM_IOS,
+        :customFields => {}
+      }
+
+==== Send the message
+
+     client.add_apn_message(params)
+
+== Examples
+
+    The provided examples illustrate how to:
+    - send a single notification to a registered device
+    - register a device
+
+== 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
+
+== Tests
+  To run the tests, issue the following command from the root of the project:
+  bundle exec rspec spec/messagebus_ruby_apn_api/client_spec.rb
+
+== License
+  Copyright 2012 Mail Bypass, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+  except in compliance with the License. You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+  either express or implied. See the License for the specific language governing permissions
+  and limitations under the License.
+
+== More info
+  Contact Message Bus if you have questions or problems (https://www.messagebus.com/contact)

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/messagebus_ruby_apn_api.rb

@@ -0,0 +1,23 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+dir = File.dirname(__FILE__)
+
+require 'net/https'
+require 'uri'
+require 'cgi'
+
+require "#{dir}/messagebus_ruby_apn_api/errors"
+require "#{dir}/messagebus_ruby_apn_api/messagebus"
+require "#{dir}/messagebus_ruby_apn_api/version"

data/lib/messagebus_ruby_apn_api/errors.rb

@@ -0,0 +1,37 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+module MessagebusApi
+
+  class APIParameterError < StandardError
+    def initialize(problematic_parameter="")
+      super("missing or malformed parameter #{problematic_parameter}")
+    end
+  end
+
+  class BadAPIKeyError < StandardError
+  end
+
+  class MissingFileError <StandardError
+  end
+
+  class RemoteServerError < StandardError
+    attr_reader :result
+    def initialize(message, result={})
+      super(message)
+      @result = result
+    end
+  end
+  
+end

data/lib/messagebus_ruby_apn_api/messagebus.rb

@@ -0,0 +1,283 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+require 'json'
+
+require 'json'
+
+module MessagebusApnApi
+  DEFAULT_API_APN_ENDPOINT_STRING = 'https://apn.messagebus.com'
+
+  class Messagebus
+
+    PLATFORM_IOS = 'ios'
+    PLATFORM_ANDROID = 'android'
+
+    attr_writer :send_common_info
+
+    def initialize(api_key)
+      @api_key = api_key
+      init_http_connection(domain)
+
+      @msg_buffer_size = 20
+      @msg_buffer = []
+      @msg_buffer_flushed = false
+
+      @register_buffer_size = 20
+      @register_buffer = []
+      @register_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 send_buffer_size=(size)
+      @msg_buffer_size = size if (size >= 1 && size <= 100)
+    end
+
+    def send_buffer_size
+      @msg_buffer_size
+    end
+
+    def send_flushed?
+      @msg_buffer_flushed
+    end
+
+    def register_buffer_size=(size)
+      @register_buffer_size = size if (size >= 1 && size <= 100)
+    end
+
+    def register_buffer_size
+      @register_buffer_size
+    end
+
+    def register_flushed?
+      @register_buffer_flushed
+    end
+
+    def api_version
+      make_api_get_call(@rest_endpoints[:version])
+    end
+
+    def add_apn_send(params, app_key, flush_buffer = false)
+      @msg_buffer << base_apn_send_params.merge!(params)
+
+      @msg_buffer_flushed = false
+      if flush_buffer || @msg_buffer.size >= @msg_buffer_size
+        apn_send_flush(app_key)
+      end
+      return
+    end
+
+    def apn_send_flush(app_key)
+      if (@msg_buffer.size==0)
+        @results=@empty_send_results
+        return
+      end
+
+      endpoint = @rest_endpoints[:apn_send].gsub("%KEY%", app_key)
+
+      json = json_apn_send_from_list(@msg_buffer)
+      if (@last_init_time < Time.now.utc - 60)
+        init_http_connection(domain)
+      end
+      @results=make_api_post_call(endpoint, json)
+      @msg_buffer.clear
+
+      @msg_buffer_flushed = true
+      return
+    end
+
+    def add_apn_register(params, app_key, flush_buffer = false)
+      @register_buffer << base_apn_register_params.merge!(params)
+
+      @register_buffer_flushed = false
+      if flush_buffer || @register_buffer.size >= @register_buffer_size
+        apn_register_flush(app_key)
+      end
+      return
+    end
+
+    def apn_register_flush(app_key)
+      if (@register_buffer.size==0)
+        @results=@empty_send_results
+        return
+      end
+
+      endpoint = @rest_endpoints[:apn_register].gsub("%KEY%", app_key)
+
+      json = json_apn_register_from_list(@register_buffer)
+      if (@last_init_time < Time.now.utc - 60)
+        init_http_connection(domain)
+      end
+      @results=make_api_post_call(endpoint, json)
+      @register_buffer.clear
+      @register_buffer_flushed = true
+      return
+    end
+
+    def get_apn_apps
+      path = @rest_endpoints[:apn_apps]
+      @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 init_http_connection(target_server)
+      if (@http and @http.started?)
+        @http.finish
+      end
+      @last_init_time = Time.now.utc
+      endpoint_url = URI.parse(target_server)
+      @http = Net::HTTP.new(endpoint_url.host, endpoint_url.port)
+      @http.use_ssl = true
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      @http
+    end
+
+    def domain
+      DEFAULT_API_APN_ENDPOINT_STRING
+    end
+
+    def common_http_headers
+      {'User-Agent' => MessagebusApi::Info.get_user_agent, 'X-MessageBus-Key' => @api_key}
+    end
+
+    def rest_post_headers
+      {"Content-Type" => "application/json; charset=utf-8"}
+    end
+
+    def json_apn_send_from_list(messages)
+      {:messages => messages}.to_json
+    end
+
+    def json_apn_register_from_list(users)
+      {:users => users}.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 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
+      {
+          :apn_register => "/api/v3/app/%KEY%/register",
+          :apn_send => "/api/v3/app/%KEY%/send",
+          :apn_apps => "/api/v3/apps",
+          :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_apn_register_params
+      {
+          :userName => '',
+          :deviceToken => '',
+          :platform => ''
+      }
+    end
+
+    def base_apn_send_params
+      {
+          :userName => '',
+          :alert => '',
+          :platform => '',
+          :customFields => {}
+      }
+    end
+
+    def base_response_params
+      {:statusCode => 0,
+       :statusMessage => "",
+       :statusTime => "1970-01-01T00:00:00.000Z"}
+    end
+  end
+end

data/lib/messagebus_ruby_apn_api/version.rb

@@ -0,0 +1,27 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+module MessagebusApi
+  VERSION = "1.0.0"
+
+  class Info
+    @@ClientVersion = MessagebusApi::VERSION
+    @@RubyVersion = RUBY_VERSION
+    @@UserAgent = "MessagebusAPI:#{@@ClientVersion}-Ruby:#{@@RubyVersion}";
+
+    def self.get_user_agent
+      return @@UserAgent
+    end
+  end
+end

data/spec/messagebus_ruby_apn_api/cacert.pem

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

data/spec/messagebus_ruby_apn_api/messagebus_spec.rb

@@ -0,0 +1,319 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+
+dir = File.dirname(__FILE__)
+require "#{dir}/../spec_helper"
+
+class MessagebusTest < MessagebusApnApi::Messagebus
+  attr_accessor :last_init_time
+end
+
+describe MessagebusApnApi::Messagebus do
+  attr_reader :client, :api_key, :required_params
+
+
+
+  def default_apn_send_params
+    {
+     :userName => 'mark@example.com',
+     :alert => 'Message Bus application push',
+     :platform => 'ios',
+     :customFields => ["badge"=>"23"]
+    }
+  end
+
+  def default_apn_register_params
+    {
+     :userName => 'mark@messagebus.com',
+     :deviceToken  => '835012e8d4640406818e8c7',
+     :platform => 'ios'
+    }
+  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
+
+    @app_key = 'test_key'
+    @api_key = "7215ee9c7d9dc229d2921a40e899ec5f"
+    @client = MessagebusTest.new(@api_key)
+    @success_message={
+        "status" => 200,
+        "messageId" => "abcdefghijklmnopqrstuvwxyz012345"
+    }
+    @simple_success_result = create_success_result(1)
+    @apn_endpoint = "https://apn.messagebus.com/api/v3/"
+  end
+
+  describe "messagebus object set up correctly" do
+    it "has correct headers set for api calls" do
+      client = MessagebusApnApi::Messagebus.new(@api_key)
+    end
+  end
+
+  describe "add cacert file to http communications" do
+    it "raises error if cert file does not exist" do
+      client = MessagebusApnApi::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 = MessagebusApnApi::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_apn_send" do
+    it "buffered send that adds to empty buffer" do
+      client.add_apn_send(default_apn_send_params, @app_key)
+      client.send_flushed?.should be_false
+    end
+    it "buffered send that adds to empty buffer and sends with flush_buffer flag" do
+      expected_request="#{@apn_endpoint}app/#{@app_key}/send"
+      FakeWeb.register_uri(:post, expected_request, :body => json_valid_apn_send)
+      client.add_apn_send(default_apn_send_params, @app_key, true)
+      client.send_flushed?.should be_true
+    end
+    it "should have user-agent and x-messagebus-key set in request headers" do
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/send", :body => json_valid_apn_send)
+      client.add_apn_send(default_apn_send_params, @app_key, true)
+      client.send_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, "#{@apn_endpoint}app/#{@app_key}/send", :body => create_success_result(client.send_buffer_size).to_json)
+        (client.send_buffer_size-1).times do |idx|
+          client.add_apn_send(default_apn_send_params, @app_key)
+          client.send_flushed?.should be_false
+        end
+        client.add_apn_send(default_apn_send_params, @app_key)
+        client.send_flushed?.should be_true
+        client.results[:results].size.should == client.send_buffer_size
+
+    end
+  end
+
+  describe "#apn_app_register" do
+    it "buffered register that adds to empty buffer" do
+      client.add_apn_register(default_apn_register_params, @app_key)
+      client.register_flushed?.should be_false
+    end
+    it "buffered register that adds to empty buffer and registers with flush_buffer flag" do
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => json_valid_apn_register)
+      client.add_apn_register(default_apn_register_params, @app_key, true)
+      client.register_flushed?.should be_true
+    end
+    it "should have user-agent and x-messagebus-key set in request headers" do
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => json_valid_apn_register)
+      client.add_apn_register(default_apn_register_params, @app_key, true)
+      client.register_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 register that adds to a buffer and auto-flushes" do
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => create_success_result(client.register_buffer_size).to_json)
+        (client.send_buffer_size-1).times do |idx|
+          client.add_apn_register(default_apn_register_params, @app_key)
+          client.register_flushed?.should be_false
+        end
+        client.add_apn_register(default_apn_register_params, @app_key)
+        client.register_flushed?.should be_true
+        client.results[:results].size.should == client.register_buffer_size
+    end
+  end
+
+  describe "#apn_send_flush" do
+    it "apn send flush called on empty buffer" do
+      client.apn_send_flush(@app_key)
+      client.send_flushed?.should be_false
+    end
+
+    it "apn send flush called on partially filled buffer" do
+      message_count = 9
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/send", :body => create_success_result(message_count).to_json)
+      (message_count).times do |idx|
+        client.add_apn_send(default_apn_send_params, @app_key)
+        client.send_flushed?.should be_false
+      end
+      client.apn_send_flush(@app_key)
+      client.send_flushed?.should be_true
+      client.results[:results].size.should == message_count
+    end
+
+    it "doesnt reset connection if under a minute old" do
+      current_init_time=client.last_init_time
+      current_init_time.should be > Time.now.utc-5
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/send", :body => create_success_result(1).to_json)
+      client.add_apn_send(default_apn_send_params, @app_key)
+      client.apn_send_flush(@app_key)
+      client.send_flushed?.should be_true
+      client.results[:results].size.should == 1
+      client.last_init_time.should == current_init_time
+    end
+
+    it "resets connection if over a minute old" do
+      client.last_init_time=Time.now.utc-60
+      current_init_time=client.last_init_time
+      current_init_time.should be < Time.now.utc-59
+      FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/send", :body => create_success_result(1).to_json)
+      client.add_apn_send(default_apn_send_params, @app_key)
+      client.apn_send_flush(@app_key)
+      client.send_flushed?.should be_true
+      client.results[:results].size.should == 1
+      client.last_init_time.should be > current_init_time
+    end
+  end
+
+  describe "#send_buffer_size=" do
+    it "can set the buffer size" do
+      client.send_buffer_size=(10)
+      client.send_buffer_size.should == 10
+    end
+
+    it "cannot set an invalid buffer size" do
+      default_buffer_size = 20
+      client.send_buffer_size=(-1)
+      client.send_buffer_size.should == default_buffer_size
+
+      client.send_buffer_size=(0)
+      client.send_buffer_size.should == default_buffer_size
+
+      client.send_buffer_size=(101)
+      client.send_buffer_size.should == default_buffer_size
+
+      client.send_buffer_size=(1)
+      client.send_buffer_size.should == 1
+
+      client.send_buffer_size=(100)
+      client.send_buffer_size.should == 100
+    end
+  end
+
+  describe "#apn_register_flush" do
+      it "apn register flush called on empty buffer" do
+        client.apn_register_flush(@app_key)
+        client.register_flushed?.should be_false
+      end
+
+      it "apn register flush called on partially filled buffer" do
+        message_count = 9
+        FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => create_success_result(message_count).to_json)
+        (message_count).times do |idx|
+          client.add_apn_register(default_apn_register_params, @app_key)
+          client.register_flushed?.should be_false
+        end
+        client.apn_register_flush(@app_key)
+        client.register_flushed?.should be_true
+        client.results[:results].size.should == message_count
+      end
+
+      it "doesnt reset connection if under a minute old" do
+        current_init_time=client.last_init_time
+        current_init_time.should be > Time.now.utc-5
+        FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => create_success_result(1).to_json)
+        client.add_apn_register(default_apn_register_params, @app_key)
+        client.apn_register_flush(@app_key)
+        client.register_flushed?.should be_true
+        client.results[:results].size.should == 1
+        client.last_init_time.should == current_init_time
+      end
+
+      it "resets connection if over a minute old" do
+        client.last_init_time=Time.now.utc-60
+        current_init_time=client.last_init_time
+        current_init_time.should be < Time.now.utc-59
+        FakeWeb.register_uri(:post, "#{@apn_endpoint}app/#{@app_key}/register", :body => create_success_result(1).to_json)
+        client.add_apn_register(default_apn_register_params, @app_key)
+        client.apn_register_flush(@app_key)
+        client.register_flushed?.should be_true
+        client.results[:results].size.should == 1
+        client.last_init_time.should be > current_init_time
+      end
+    end
+
+    describe "#register_buffer_size=" do
+      it "can set the buffer size" do
+        client.register_buffer_size=(10)
+        client.register_buffer_size.should == 10
+      end
+
+      it "cannot set an invalid buffer size" do
+        default_buffer_size = 20
+        client.register_buffer_size=(-1)
+        client.register_buffer_size.should == default_buffer_size
+
+        client.register_buffer_size=(0)
+        client.register_buffer_size.should == default_buffer_size
+
+        client.register_buffer_size=(101)
+        client.register_buffer_size.should == default_buffer_size
+
+        client.register_buffer_size=(1)
+        client.register_buffer_size.should == 1
+
+        client.register_buffer_size=(100)
+        client.register_buffer_size.should == 100
+      end
+    end
+
+
+  describe "#get_apn_apps" do
+    it "can return a list of apps with name and app key" do
+      FakeWeb.register_uri(:get, "#{@apn_endpoint}apps", :body => json_valid_apn_apps)
+      expect do
+        response = client.get_apn_apps
+        FakeWeb.last_request.body.should be_nil
+        response.should == json_parse(json_valid_apn_apps)
+      end.should_not raise_error
+    end
+  end
+end

data/spec/spec_core_extensions.rb

@@ -0,0 +1,19 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+class Hash
+  def without(key)
+    self.dup.tap{|hash| hash.delete(key)}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+# Copyright 2012 Mail Bypass, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+dir = File.dirname(__FILE__)
+
+require 'rubygems'
+require 'fakeweb'
+require 'rr'
+require 'json'
+
+require "#{dir}/spec_core_extensions"
+require "#{dir}/../lib/messagebus_ruby_apn_api"
+
+def json_valid_apn_send
+  json = <<JAVASCRIPT
+{"statusCode":202,"statusMessage":"","statusTime":"2011-09-19T22:40:45.123Z","successCount":1,"failureCount":0,"results":[{"userName":"mark@messagebus.com","registrationStatus":"0"}]}
+JAVASCRIPT
+  json
+end
+
+def json_valid_apn_register
+  json = <<JAVASCRIPT
+{"statusCode":202,"statusMessage":"","statusTime":"2011-09-19T22:40:45.123Z","successCount":1,"failureCount":0,"results":[{"userName":"mark@messagebus.com","platform":"ios","messageStatus":0}]}
+JAVASCRIPT
+end
+
+def json_valid_apn_apps
+  json = <<JAVASCRIPT
+{"statusCode":202, "statusMessage":"", "statusTime":"2011-09-19T22:40:45.123Z","results":[{"appName":"Sample App","appKey":"<app key>"}]}
+JAVASCRIPT
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: messagebus_ruby_apn_api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Message Bus dev team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-02 00:00:00.000000000Z
+dependencies: []
+description: ! 'Allows you to use the Message Bus API '
+email:
+- messagebus@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/messagebus_ruby_apn_api/errors.rb
+- lib/messagebus_ruby_apn_api/messagebus.rb
+- lib/messagebus_ruby_apn_api/version.rb
+- lib/messagebus_ruby_apn_api.rb
+- spec/messagebus_ruby_apn_api/cacert.pem
+- spec/messagebus_ruby_apn_api/messagebus_spec.rb
+- spec/spec_core_extensions.rb
+- spec/spec_helper.rb
+- README.rdoc
+- Gemfile
+- Rakefile
+- .rvmrc
+homepage: ''
+licenses:
+- APACHE2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: messagebus_ruby_apn_api
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Send application push notifications through the Message Bus service
+test_files:
+- spec/messagebus_ruby_apn_api/cacert.pem
+- spec/messagebus_ruby_apn_api/messagebus_spec.rb
+- spec/spec_core_extensions.rb
+- spec/spec_helper.rb