apn_client 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+spec/certificate.pem
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.rvmrc

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.2-p180@apn_client"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && ! command -v bundle >/dev/null
+# then
+#   printf "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && command -v bundle
+# then
+#   bundle install
+# fi
+
+if [[ $- == *i* ]] # check for interactive shells
+then
+    echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+else 
+	echo "Using: $GEM_HOME" # don't use colors in interactive shells
+fi
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in apn_client.gemspec
+gemspec

data/README.md

@@ -0,0 +1,88 @@
+# APN Client RubyGem
+
+## Introduction
+
+This is a RubyGem that allows sending of Apple Push Notifications to iOS devices (i.e. iPhones, iPads) from Ruby. The main features are:
+
+* Broadcasting of notifications to a large number of devices in a reliable fashion
+* Dealing with errors (via the enhanced format Apple protocol) when sending notifications
+* Reading from the Apple Feedback Service to avoid sending to devices with uninstalled applications
+
+## Usage
+
+### 1. Configure the Connection
+
+```
+
+ApnClient::Delivery.connection_config = {
+  :host => 'gateway.push.apple.com', # For sandbox, use: gateway.sandbox.push.apple.com
+  :port => 2195,
+  :certificate => IO.read("my_apn_certificate.pem"),
+  :certificate_passphrase => '',
+}
+
+ApnClient::Feedback.connection_config = {
+  :host => 'feedback.push.apple.com', # For sandbox, use: feedback.sandbox.push.apple.com
+  :port => 2196,
+  :certificate => IO.read("my_apn_certificate.pem"),
+  :certificate_passphrase => '',
+}
+
+```
+
+### 2. Deliver Your Message
+
+```
+message1 = ApnClient::Message.new(1,
+  :device_token => "7b7b8de5888bb742ba744a2a5c8e52c6481d1deeecc283e830533b7c6bf1d099",
+  :alert => "New version of the app is out. Get it now in the app store!",
+  :badge => 2
+)
+message2 = ApnClient::Message.new(2,
+  :device_token => "6a5g4de5888bb742ba744a2a5c8e52c6481d1deeecc283e830533b7c6bf1d044",
+  :alert => "New version of the app is out. Get it now in the app store!",
+  :badge => 1
+)
+delivery = ApnClient::Delivery.new([message1, message2],
+  :callbacks => {
+    :on_write => lambda { |d, m| puts "Wrote message #{m}" },
+    :on_exception => lambda { |d, m, e| puts "Exception #{e} raised when delivering message #{m}" },
+    :on_failure => lambda { |d, m| puts "Skipping failed message #{m}" },
+    :on_error => lambda { |d, message_id, error_code| puts "Received error code #{error_code} from Apple for message #{message_id}" }
+  },
+  :consecutive_failure_limit => 10, # If more than 10 devices in a row fail, we abort the whole delivery
+  :exception_limit => 3 # If a device raises an exception three times in a row we fail/skip the device and move on
+)
+delivery.process!
+puts "Delivered successfully to #{delivery.success_count} out of #{delivery.total_count} devices in #{delivery.elapsed} seconds"
+```
+
+One potential gotcha to watch out for is that the device token for a message is per device and per application. This means
+that different apps on the same device will have different tokens. The Apple documentation uses phone numbers as an analogy
+to explain what a device token is.
+
+### 3. Check for Feedback
+
+TODO
+
+## Dependencies
+
+The payload of an APN message is a JSON formated hash (containing alert message, badge count, content available etc.) and therefore a JSON library needs to be present. This gem requires a Hash#to_json method to be defined (hashes need to respond
+to to_json and return valid JSON). If you for example have the json gem or the rails gem in your environment then this requirement is fulfilled.
+
+The gem is tested on MRI 1.9.2.
+
+## Credits
+
+This gem is an extraction of production code at [Mag+](http://www.magplus.com) and both [Dennis Rogenius](https://github.com/denro) and [Lennart Friden](https://github.com/DevL) made important contributions along the way.
+
+The APN connection code has its origins in the [APN on Rails](https://github.com/jwang/apn_on_rails) gem.
+
+## License
+
+This library is released under the MIT license.
+
+## Resources
+
+* [Apple Push Notifications Documentation](http://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008194-CH1-SW1)
+* [The APNS RubyGem](https://github.com/jpoz/APNS). Has a small codebase and a nice API. Does not use the enhanced format protocol and lacks error handling.

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/apn_client.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "apn_client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "apn_client"
+  s.version     = ApnClient::VERSION
+  s.authors     = ["Peter Marklund"]
+  s.email       = ["peter@marklunds.com"]
+  s.homepage    = ""
+  s.summary     = %q{Library for sending Apple Push Notifications to iOS devices from Ruby}
+  s.description = %q{Uses the "enhanced format" Apple protocol and deals with errors and failures when broadcasting to many devices. Includes support for talking to the Apple Push Notification Feedback service for dealing with uninstalled apps.}
+
+  s.rubyforge_project = "apn_client"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "json"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "yard"
+end

data/lib/apn_client/connection.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'openssl'
+require 'apn_client/named_args'
+
+module ApnClient
+  class Connection
+    attr_accessor :config, :tcp_socket, :ssl_socket
+
+    # Opens an SSL socket for talking to the Apple Push Notification service.
+    #
+    # @param [String] host the hostname to connect to
+    # @param [Fixnum] port the port to connect to
+    # @param [String] certificate the APN certificate to use
+    # @param [String] certificate_passphrase the passphrase of the certificate, can be empty
+    # @param [Float] select_timeout the timeout (seconds) used when doing IO.select on the socket (default 0.1)
+    def initialize(config = {})
+      NamedArgs.assert_valid!(config,
+        :required => [:host, :port, :certificate, :certificate_passphrase],
+        :optional => [:select_timeout])
+      self.config = config
+      config[:select_timeout] ||= 0.1
+      connect_to_socket
+    end
+
+    def close
+      ssl_socket.close
+      tcp_socket.close
+      self.ssl_socket = nil
+      self.tcp_socket = nil
+    end
+
+     def write(arg)
+       ssl_socket.write(arg.to_s)
+     end
+
+     def read(*args)
+       ssl_socket.read(*args)
+     end
+
+     def select
+       IO.select([ssl_socket], nil, nil, config[:select_timeout])
+     end
+
+     def self.open(options = {})
+       connection = Connection.new(options)
+       yield connection
+     ensure
+       connection.close if connection
+     end
+
+    private
+
+    def connect_to_socket
+      context = OpenSSL::SSL::SSLContext.new
+      context.key = OpenSSL::PKey::RSA.new(config[:certificate], config[:certificate_passphrase])
+      context.cert = OpenSSL::X509::Certificate.new(config[:certificate])
+
+      self.tcp_socket = TCPSocket.new(config[:host], config[:port])
+      self.ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, context)
+      ssl_socket.sync = true
+      ssl_socket.connect
+    end
+  end
+end

data/lib/apn_client/delivery.rb

@@ -0,0 +1,147 @@
+require 'apn_client/named_args'
+require 'apn_client/message'
+require 'apn_client/connection'
+
+module ApnClient
+  class Delivery
+    attr_accessor :messages, :callbacks, :consecutive_failure_limit, :exception_limit, :sleep_on_exception,
+      :exception_count, :success_count, :failure_count, :consecutive_failure_count,
+      :started_at, :finished_at
+
+    # Creates a new APN delivery
+    #
+    # @param [#next] messages should be Enumerator type object that responds to #next. If it's an Array #shift will be used instead.
+    def initialize(messages, options = {})
+      self.messages = messages
+      initialize_options(options)
+      self.exception_count = 0
+      self.success_count = 0
+      self.failure_count = 0
+      self.consecutive_failure_count = 0
+    end
+
+    def process!
+      self.started_at = Time.now
+      while current_message && consecutive_failure_count < consecutive_failure_limit
+        process_one_message!
+      end
+      close_connection
+      self.finished_at = Time.now
+    end
+
+    def elapsed
+      if started_at
+        finished_at ? (finished_at - started_at) : (Time.now - started_at)
+      else
+        0
+      end
+    end
+
+    def total_count
+      success_count + failure_count
+    end
+
+    private
+
+    def initialize_options(options)
+      NamedArgs.assert_valid!(options, :optional => [:callbacks, :consecutive_failure_limit, :exception_limit, :sleep_on_exception])
+      NamedArgs.assert_valid!(options[:callbacks], :optional => [:on_write, :on_error, :on_nil_select, :on_read_exception, :on_exception, :on_failure])
+      self.callbacks = options[:callbacks]
+      self.consecutive_failure_limit = options[:consecutive_failure_limit] || 10
+      self.exception_limit = options[:exception_limit] || 3
+      self.sleep_on_exception = options[:sleep_on_exception] || 1      
+    end
+    
+    def current_message
+      return @current_message if @current_message
+      next_message!
+    end
+    
+    def next_message!
+      @current_message = (messages.respond_to?(:next) ? messages.next : messages.shift)
+    rescue StopIteration
+      nil
+    end
+    
+    def process_one_message!
+      begin
+        write_message!
+        check_message_error!
+      rescue Exception => e
+        handle_exception!(e)
+        check_message_error! unless @checked_message_error
+        close_connection
+      end
+    end
+
+    def connection
+      @connection ||= Connection.new(self.class.connection_config)
+    end
+
+    def close_connection
+      @connection.close if @connection
+      @connection = nil
+    end
+
+    def write_message!
+      @checked_message_error = false
+      connection.write(current_message)
+      self.exception_count = 0; self.consecutive_failure_count = 0; self.success_count += 1
+      invoke_callback(:on_write, current_message)
+      next_message!
+    end
+    
+    def check_message_error!
+      @checked_message_error = true
+      failed_message_id, error_code = read_apns_error
+      # NOTE: According to the APN documentation the APN service will return an error code prior to
+      # disconnecting. If we don't disconnect here we will attempt to write more messages
+      # before a broken pipe error is raised and those messages will never be delivered.
+      if failed_message_id
+        invoke_callback(:on_error, failed_message_id, error_code)
+        self.failure_count += 1
+        self.success_count -= 1
+        close_connection
+      end
+    end
+
+    def read_apns_error
+      message_id = error_code = nil
+      begin
+        select_return = nil
+        if connection && select_return = connection.select
+          response = connection.read(6)
+          command, error_code, message_id = response.unpack('cci') if response
+        else
+          invoke_callback(:on_nil_select)
+        end
+      rescue Exception => e
+        # NOTE: If we don't catch this exception then one socket read exception could break out of the whole delivery loop
+        invoke_callback(:on_read_exception, e)
+      end
+      return message_id, error_code
+    end
+
+    def handle_exception!(e)
+      invoke_callback(:on_exception, e)
+      self.exception_count += 1
+      fail_message! if exception_limit_reached?
+      sleep(sleep_on_exception) if sleep_on_exception
+    end
+
+    def exception_limit_reached?
+      exception_count == exception_limit
+    end
+
+    # # Give up on the message and move on to the next one
+    def fail_message!
+      self.failure_count += 1; self.consecutive_failure_count += 1; self.exception_count = 0
+      invoke_callback(:on_failure, current_message)
+      next_message!
+    end
+    
+    def invoke_callback(name, *args)
+      callbacks[name].call(self, *args) if callbacks[name]
+    end
+  end
+end

data/lib/apn_client/message.rb

@@ -0,0 +1,85 @@
+require 'apn_client/named_args'
+
+module ApnClient
+  class Message
+    attr_accessor :message_id, :device_token, :alert, :badge, :sound, :content_available, :custom_properties
+
+    # Creates an APN message to to be sent over SSL to the APN service.
+    #
+    # @param [Fixnum] message_id a unique (at least within a delivery) integer identifier for this message
+    # @param [String] device_token A 64 byte long hex digest supplied from an app installed on a device to the server
+    # @param [String] alert A text message to display to the user. Should be tweet sized (payload may not exceed 256 bytes)
+    # @param [Fixnum] badge the number to show on the badge on the app icon - number of new/unread items
+    # @param [String] sound filename of a sound file in the app bundle to be played to the user
+    # @param [Boolean] content_available set to true if the message should trigger download of new content
+    def initialize(message_id, config = {})
+      self.message_id = message_id
+      self.device_token = device_token
+      NamedArgs.assert_valid!(config,
+        :optional => [:alert, :badge, :sound, :content_available],
+        :required => [:device_token])
+      config.keys.each do |key|
+        send("#{key}=", config[key])
+      end
+      check_payload_size!
+    end
+
+    # We use the enhanced format. See the Apple documentation for details.
+    def to_s
+      [1, message_id, self.class.expires_at, 0, 32, device_token, 0, payload_size, payload].pack('ciiccH*cca*')
+    end
+
+    def self.error_codes
+      {
+          :no_errors_encountered => 0,
+          :processing_error => 1,
+          :missing_device_token => 2,
+          :missing_topic => 3,
+          :missing_payload => 4,
+          :invalid_token_size => 5,
+          :invalid_topic_size => 6,
+          :invalid_payload_size => 7,
+          :invalid_token => 8,
+          :unknown => 255
+      }
+    end
+
+    def self.expires_at
+      seconds_per_day = 24*3600
+      (Time.now + 30*seconds_per_day).to_i
+    end
+
+    # The payload is a JSON formated hash with alert, sound, badge, content-available,
+    # and any custom properties, example:
+    # {"aps" => {"badge" => 5, "sound" => "my_sound.aiff", "alert" => "Hello!"}}
+    def payload
+      payload_hash.to_json
+    end
+
+    def payload_hash
+      result = {}
+      result['aps'] = {}
+      result['aps']['alert'] = alert if alert
+      result['aps']['badge'] = badge if badge and badge > 0
+      if sound
+        result['aps']['sound'] = sound if sound.is_a? String
+        result['aps']['sound'] = "1.aiff" if sound.is_a? TrueClass
+      end
+      result['aps']['content-available'] = 1 if content_available
+      result
+    end
+
+    def payload_size
+      payload.bytesize
+    end
+
+    private
+
+    def check_payload_size!
+      max_payload_size = 256
+      if payload_size > max_payload_size
+        raise "Payload is #{payload_size} bytes and it cannot exceed #{max_payload_size} bytes"
+      end
+    end
+  end
+end

data/lib/apn_client/named_args.rb

@@ -0,0 +1,25 @@
+module ApnClient
+  class NamedArgs
+    def self.assert_valid!(arguments, options)
+      arguments ||= {}
+      options[:optional] ||= []
+      options[:required] ||= []
+      assert_allowed!(arguments, options[:optional] + options[:required])
+      assert_present!(arguments, options[:required])
+    end
+
+    def self.assert_allowed!(arguments, allowed_keys)
+      invalid_keys = arguments.keys.select { |key| !allowed_keys.include?(key) }
+      unless invalid_keys.empty?
+        raise "Invalid arguments: #{invalid_keys.join(', ')}. Must be one of #{allowed_keys.join(', ')}"
+      end
+    end
+
+    def self.assert_present!(arguments, required_keys)
+      missing_keys = required_keys.select { |key| !arguments.keys.include?(key) }
+      unless missing_keys.empty?
+        raise "Missing required arguments: #{missing_keys.join(', ')}"
+      end
+    end
+  end
+end

data/lib/apn_client/version.rb

@@ -0,0 +1,3 @@
+module ApnClient
+  VERSION = "0.0.1"
+end

data/lib/apn_client.rb

@@ -0,0 +1,5 @@
+require "apn_client/version"
+
+module ApnClient
+  # Your code goes here...
+end

data/spec/connection_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+require 'apn_client/connection'
+
+describe ApnClient::Connection do
+  describe "#initialize" do
+    it "opens an SSL connection given host, port, certificate, and certificate_passphrase" do
+      if certificate_exists?
+        connection = ApnClient::Connection.new(valid_config)
+        connection.config.should == valid_config_with_defaults
+        connection.tcp_socket.is_a?(TCPSocket).should be_true
+        connection.ssl_socket.is_a?(OpenSSL::SSL::SSLSocket).should be_true
+      end
+    end
+
+    it "raises an exception if a required argument is missing" do
+      if certificate_exists?
+        TCPSocket.expects(:new).never
+        lambda {
+          connection = ApnClient::Connection.new(valid_config.reject { |key| key == :host })
+        }.should raise_error(/host/)
+      end
+    end
+
+    it "can take a select_timeout argument" do
+      if certificate_exists?
+        config = valid_config.merge(:select_timeout => 0.5)
+        connection = ApnClient::Connection.new(config)
+        connection.config.should == config
+        connection.tcp_socket.is_a?(TCPSocket).should be_true
+        connection.ssl_socket.is_a?(OpenSSL::SSL::SSLSocket).should be_true
+      end
+    end
+
+    it "does not accept invalid arguments" do
+      invalid_config = valid_config.merge({:foobar => 1})
+      TCPSocket.expects(:new).never
+      lambda {
+        ApnClient::Connection.new(invalid_config)
+      }.should raise_error(/foobar/)
+    end
+  end
+
+  describe "#close" do
+    it "closes ssl and tcp sockets and sets them to nil" do
+      if certificate_exists?
+        connection = ApnClient::Connection.new(valid_config)
+        connection.close
+        connection.tcp_socket.should be_nil
+        connection.ssl_socket.should be_nil
+      end
+    end
+  end
+
+  describe "#write" do
+    it "invokes write on the ssl socket" do
+      ApnClient::Connection.any_instance.expects(:connect_to_socket)
+      connection = ApnClient::Connection.new(valid_config)
+      ssl_socket = mock('ssl_socket')
+      ssl_socket.expects(:write).with('foo')
+      connection.expects(:ssl_socket).returns(ssl_socket)
+      connection.write(:foo)
+    end
+  end
+
+  describe "#read" do
+    it "invokes read on the ssl socket" do
+      ApnClient::Connection.any_instance.expects(:connect_to_socket)
+      connection = ApnClient::Connection.new(valid_config)
+      ssl_socket = mock('ssl_socket')
+      ssl_socket.expects(:read).with("foo", "bar")
+      connection.expects(:ssl_socket).returns(ssl_socket)
+      connection.read("foo", "bar")
+    end
+  end
+
+  describe "#select" do
+    it "does an IO.select on the ssl socket with a timeout" do
+      ApnClient::Connection.any_instance.expects(:connect_to_socket)
+      connection = ApnClient::Connection.new(valid_config.merge(:select_timeout => 0.9))
+      ssl_socket = mock('ssl_socket')
+      connection.expects(:ssl_socket).returns(ssl_socket)
+      IO.expects(:select).with([ssl_socket], nil, nil, 0.9)
+      connection.select
+    end
+  end
+
+  describe ".open" do
+    it "opens a connection, yields it to a block, then closes it" do
+      ApnClient::Connection.any_instance.expects(:connect_to_socket)
+      ApnClient::Connection.any_instance.expects(:close)
+      ApnClient::Connection.open(valid_config) do |connection|
+        connection.config.should == valid_config_with_defaults
+      end
+    end
+  end
+
+  def certificate_path
+    File.join(File.dirname(__FILE__), "certificate.pem")
+  end
+
+  def certificate_exists?
+    File.exists?(certificate_path)
+  end
+
+  def valid_config
+    {
+        :host => 'gateway.push.apple.com',
+        :port => 2195,
+        :certificate => IO.read(certificate_path),
+        :certificate_passphrase => ''
+    }
+  end
+
+  def valid_config_with_defaults
+    valid_config.merge(:select_timeout => 0.1)
+  end
+end

data/spec/delivery_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+require 'apn_client/delivery'
+
+describe ApnClient::Delivery do
+  before(:each) do
+    @message1 = ApnClient::Message.new(1,
+      :device_token => "7b7b8de5888bb742ba744a2a5c8e52c6481d1deeecc283e830533b7c6bf1d099",
+      :alert => "New version of the app is out. Get it now in the app store!",
+      :badge => 2
+    )
+    @message2 = ApnClient::Message.new(2,
+      :device_token => "6a5g4de5888bb742ba744a2a5c8e52c6481d1deeecc283e830533b7c6bf1d044",
+      :alert => "New version of the app is out. Get it now in the app store!",
+      :badge => 1
+    )
+  end
+
+  describe "#initialize" do
+    it "initializes counts and other attributes" do
+      delivery = create_delivery([@message1, @message2])
+    end
+  end
+
+  describe "#process!" do
+    it "can deliver to all messages successfully and invoke on_write callback" do
+      messages = [@message1, @message2]
+      written_messages = []
+      nil_selects = 0
+      callbacks = {
+          :on_write => lambda { |d, m| written_messages << m },
+          :on_nil_select => lambda { |d| nil_selects += 1 }
+        }
+      delivery = create_delivery(messages.dup, :callbacks => callbacks)
+
+      connection = mock('connection')
+      connection.expects(:write).with(@message1)
+      connection.expects(:write).with(@message2)
+      connection.expects(:select).times(2).returns(nil)
+      delivery.stubs(:connection).returns(connection)
+
+      delivery.process!
+
+      delivery.failure_count.should == 0
+      delivery.success_count.should == 2
+      delivery.total_count.should == 2
+      written_messages.should == messages
+      nil_selects.should == 2
+    end
+
+    it "fails a message if it fails more than 3 times" do
+      messages = [@message1, @message2]
+      written_messages = []
+      exceptions = []
+      failures = []
+      read_exceptions = []
+      callbacks = {
+          :on_write => lambda { |d, m| written_messages << m },
+          :on_exception => lambda { |d, e| exceptions << e },
+          :on_failure => lambda { |d, m| failures << m },
+          :on_read_exception => lambda { |d, e| read_exceptions << e }
+        }
+      delivery = create_delivery(messages.dup, :callbacks => callbacks)
+
+      connection = mock('connection')
+      connection.expects(:write).with(@message1).times(3).raises(RuntimeError)
+      connection.expects(:write).with(@message2)
+      connection.expects(:select).times(4).raises(RuntimeError)
+      delivery.stubs(:connection).returns(connection)
+
+      delivery.process!
+
+      delivery.failure_count.should == 1
+      delivery.success_count.should == 1
+      delivery.total_count.should == 2
+      written_messages.should == [@message2]
+      exceptions.size.should == 3
+      exceptions.first.is_a?(RuntimeError).should be_true
+      failures.should == [@message1]
+      read_exceptions.size.should == 4
+    end
+
+    it "invokes on_error callback if there are errors read" do
+      messages = [@message1, @message2]
+      written_messages = []
+      exceptions = []
+      failures = []
+      read_exceptions = []
+      errors = []
+      callbacks = {
+          :on_write => lambda { |d, m| written_messages << m },
+          :on_exception => lambda { |d, e| exceptions << e },
+          :on_failure => lambda { |d, m| failures << m },
+          :on_read_exception => lambda { |d, e| read_exceptions << e },
+          :on_error => lambda { |d, message_id, error_code| errors << [message_id, error_code] }
+        }
+      delivery = create_delivery(messages.dup, :callbacks => callbacks)
+
+      connection = mock('connection')
+      connection.expects(:write).with(@message1)
+      connection.expects(:write).with(@message2)
+      selects = sequence('selects')
+      connection.expects(:select).returns("something").in_sequence(selects)
+      connection.expects(:select).returns(nil).in_sequence(selects)
+      connection.expects(:read).returns("something")
+      delivery.stubs(:connection).returns(connection)
+
+      delivery.process!
+
+      delivery.failure_count.should == 1
+      delivery.success_count.should == 1
+      delivery.total_count.should == 2
+      written_messages.should == [@message1, @message2]
+      exceptions.size.should == 0
+      failures.size.should == 0
+      errors.should == [[1752458605, 111]]
+    end
+  end
+
+  def create_delivery(messages, options = {})
+    delivery = ApnClient::Delivery.new(messages, options)
+    delivery.messages.should == messages
+    delivery.callbacks.should == options[:callbacks]
+    delivery.exception_count.should == 0
+    delivery.success_count.should == 0
+    delivery.failure_count.should == 0
+    delivery.consecutive_failure_count.should == 0
+    delivery.started_at.should be_nil
+    delivery.finished_at.should be_nil
+    delivery.elapsed.should == 0
+    delivery.consecutive_failure_limit.should == 10
+    delivery.exception_limit.should == 3
+    delivery.sleep_on_exception.should == 1
+    delivery
+  end
+end

data/spec/message_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+require 'apn_client/message'
+
+describe ApnClient::Message do
+  before(:each) do
+    @device_token = "7b7b8de5888bb742ba744a2a5c8e52c6481d1deeecc283e830533b7c6bf1d099"
+    @alert = "Hello, check out version 9.5 of our awesome app in the app store"
+    @badge = 3
+  end
+
+  describe "#initialize" do
+    it "cannot be created without a token" do
+      lambda {
+        ApnClient::Message.new(1)
+      }.should raise_error(/device_token/)
+    end
+
+    it "can be created with a token and an alert" do
+      message = create_message(1, :device_token => @device_token, :alert => @alert)
+      message.payload_hash.should == {'aps' => {'alert' => @alert}}
+    end
+
+    it "can be created with a token and an alert and a badge" do
+      message = create_message(1, :device_token => @device_token, :alert => @alert, :badge => @badge)
+      message.payload_hash.should == {'aps' => {'alert' => @alert, 'badge' => @badge}}
+    end
+
+    it "can be created with a token and an alert and a badge and content-available" do
+      message = create_message(1,
+        :device_token => @device_token,
+        :alert => @alert,
+        :badge => @badge,
+        :content_available => true)
+      message.payload_hash.should == {'aps' => {'alert' => @alert, 'badge' => @badge, 'content-available' => 1}}
+    end
+
+    it "raises an exception if payload_size exceeds 256 bytes" do
+      lambda {
+        too_long_alert = "A"*1000
+        ApnClient::Message.new(1, :device_token => @device_token, :alert => too_long_alert)
+      }.should raise_error(/payload/i)
+    end
+  end
+
+  describe "#payload_size" do
+    it "returns number of bytes in the payload"
+  end
+
+  def create_message(message_id, config = {})
+    message = ApnClient::Message.new(message_id, config)
+    message.message_id.should == 1
+    [:device_token, :alert, :badge, :sound, :content_available].each do |attribute|
+      message.send(attribute).should == config[attribute]
+    end
+    message.payload_size.should < 256
+    message.to_s.should_not be_nil
+    message
+  end
+end

data/spec/named_args_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+require 'apn_client/named_args'
+
+describe ApnClient::NamedArgs do
+  describe ".assert_allowed!" do
+    it "raises an exception if the argument hash contains a key not in the allowed list" do
+      lambda {
+        ApnClient::NamedArgs.assert_allowed!({:foo => 1, :bla => 2}, [:foo, :bar])
+      }.should raise_error(/foo/)
+    end
+
+    it "does not raise an exception if the arguments hash is empty" do
+      ApnClient::NamedArgs.assert_allowed!({}, [:foo, :bar])
+    end
+
+    it "does not raise an exception if all allowed keys are provided" do
+      ApnClient::NamedArgs.assert_allowed!({:foo => 1, :bar => 2}, [:foo, :bar])
+    end
+
+    it "does not raise an exception if a subset of allowed keys are provided" do
+      ApnClient::NamedArgs.assert_allowed!({:foo => 1}, [:foo, :bar])
+    end
+  end
+
+  describe ".assert_present!" do
+    it "raises an exception if arguments are empty and required keys are not empty" do
+      lambda {
+        ApnClient::NamedArgs.assert_present!({}, [:foo])
+      }.should raise_error(/foo/)
+    end
+
+    it "does not raise an exception if arguments are empty and required keys are empty" do
+      ApnClient::NamedArgs.assert_present!({}, [])
+    end
+
+    it "raises an exception if arguments have some but not all required keys" do
+      lambda {
+        ApnClient::NamedArgs.assert_present!({:bar => 1}, [:foo, :bar])
+      }.should raise_error(/foo/)
+    end
+
+    it "does not raise an excpeption if arguments have all required keys" do
+      ApnClient::NamedArgs.assert_present!({:foo => 1, :bar => 2}, [:foo, :bar])
+    end
+  end
+
+  describe ".assert_valid!" do
+    it "can take only optional keys" do
+      arguments = {:foo => 1}
+      ApnClient::NamedArgs.expects(:assert_allowed!).with(arguments, [:foo])
+      ApnClient::NamedArgs.expects(:assert_present!).with(arguments, [])
+      ApnClient::NamedArgs.assert_valid!(arguments, :optional => [:foo])
+    end
+
+    it "can take only required keys" do
+      arguments = {:foo => 1}
+      ApnClient::NamedArgs.expects(:assert_allowed!).with(arguments, [:foo])
+      ApnClient::NamedArgs.expects(:assert_present!).with(arguments, [:foo])
+      ApnClient::NamedArgs.assert_valid!(arguments, :required => [:foo])
+    end
+
+    it "can take both optional and required keys" do
+      arguments = {:foo => 1}
+      ApnClient::NamedArgs.expects(:assert_allowed!).with(arguments, [:bar, :foo])
+      ApnClient::NamedArgs.expects(:assert_present!).with(arguments, [:foo])
+      ApnClient::NamedArgs.assert_valid!(arguments, :required => [:foo], :optional => [:bar])
+    end
+
+    it "does not raise exception if only required args are provided" do
+      ApnClient::NamedArgs.assert_valid!({:foo => 1}, :required => [:foo], :optional => [:bar])
+    end
+
+    it "does not raise exception if required and optional args are provided" do
+      ApnClient::NamedArgs.assert_valid!({:foo => 1, :bar => 2}, :required => [:foo], :optional => [:bar])
+    end
+
+    it "raises an exception if a required arg is missing" do
+      lambda {
+        ApnClient::NamedArgs.assert_valid!({:bar => 2}, :required => [:foo], :optional => [:bar])
+      }.should raise_error(/foo/)
+    end
+
+    it "raises an exception if an invalid arg is present" do
+      lambda {
+        ApnClient::NamedArgs.assert_valid!({:foo => 1, :bar => 2, :bla => 3}, :required => [:foo], :optional => [:bar])
+      }.should raise_error(/bla/)
+    end
+
+    it "does not raise an exception if args are nil and all keys are optional" do
+      ApnClient::NamedArgs.assert_valid!(nil, :optional => [:bar])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'json'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: apn_client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Peter Marklund
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70199261615240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199261615240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70199261614820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199261614820
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70199261614400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199261614400
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70199261613980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199261613980
+description: Uses the "enhanced format" Apple protocol and deals with errors and failures
+  when broadcasting to many devices. Includes support for talking to the Apple Push
+  Notification Feedback service for dealing with uninstalled apps.
+email:
+- peter@marklunds.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- apn_client.gemspec
+- lib/apn_client.rb
+- lib/apn_client/connection.rb
+- lib/apn_client/delivery.rb
+- lib/apn_client/message.rb
+- lib/apn_client/named_args.rb
+- lib/apn_client/version.rb
+- spec/connection_spec.rb
+- spec/delivery_spec.rb
+- spec/message_spec.rb
+- spec/named_args_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+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: apn_client
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Library for sending Apple Push Notifications to iOS devices from Ruby
+test_files:
+- spec/connection_spec.rb
+- spec/delivery_spec.rb
+- spec/message_spec.rb
+- spec/named_args_spec.rb
+- spec/spec_helper.rb
+has_rdoc: