pling 0.1.0 → 0.2.0

data/lib/pling/message.rb

@@ -12,6 +12,58 @@ module Pling
       body &&= body.to_s
       @body = body
     end
+    
+    ##
+    # The message subject - not supported by all gateways
+    #
+    # @overload subject
+    # @overload subject=(subject)
+    #   @param [#to_s] subject
+    attr_reader :subject
+    
+    def subject=(subject)
+      subject &&= subject.to_s
+      @subject = subject
+    end
+    
+    ##
+    # The message badge - not supported by all gateways
+    #
+    # @overload badge
+    # @overload badge=(badge)
+    #   @param [#to_s] badge
+    attr_reader :badge
+    
+    def badge=(badge)
+      badge &&= badge.to_s
+      @badge = badge
+    end
+    
+    ##
+    # The message sound - not supported by all gateways
+    #
+    # @overload sound
+    # @overload sound=(sound)
+    #   @param [#to_s] sound
+    attr_reader :sound
+    
+    def sound=(sound)
+      sound &&= sound.to_s
+      @sound = sound
+    end
+    
+    ##
+    # The message payload - not supported by all gateways
+    #
+    # @overload payload
+    # @overload payload=(sound)
+    #   @param [#to_hash] payload
+    attr_reader :payload
+    
+    def payload=(payload)
+      payload &&= payload.to_hash
+      @payload = payload
+    end
 
     ##
     # Creates a new Pling::Message instance with the given body

data/lib/pling/middleware/base.rb

@@ -1,12 +1,43 @@
 module Pling
   module Middleware
+    ##
+    # This is the base class to implement custom middleware for pling.
+    #
+    # Middleware should inherit from this base class and implement a {#deliver} method.
+    # To call the next middleware on the stack this method must yield passing the given
+    # message and device.
+    #
+    # @example
+    #
+    #     class Pling::Middleware::TimeFilter < Pling::Middleware::Base
+    #       def deliver(message, device)
+    #         yield(message, device) if configuration[:range].include? Time.now.hour
+    #       end
+    #     
+    #       protected
+    #     
+    #         def default_configuration
+    #           super.merge({
+    #             :range => 8..22
+    #           })
+    #         end
+    #     end
     class Base
       include Pling::Configurable
 
+      ##
+      # Initializes a new middleware instance
+      #
+      # @param [Hash] configuration
       def initialize(configuration = {})
         setup_configuration(configuration)
       end
 
+      ##
+      # Processes the given message and device and passes it to the next
+      # middleware on the stack.
+      #
+      # @yield [message, device] Call the next middleware on the stack
       def deliver(message, device)
         yield(message, device)
       end

data/lib/pling/version.rb

@@ -1,3 +1,3 @@
 module Pling
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/pling.rb

@@ -1,10 +1,13 @@
-require "pling/version"
+require 'pling/version'
+require 'logger'
 
 module Pling
 
   autoload :Device,       'pling/device'
   autoload :Message,      'pling/message'
   autoload :Gateway,      'pling/gateway'
+  autoload :APN,          'pling/apn'
+  autoload :C2DM,         'pling/c2dm'
   autoload :Middleware,   'pling/middleware'
   autoload :Adapter,      'pling/adapter'
   autoload :Configurable, 'pling/configurable'
@@ -13,12 +16,23 @@ module Pling
   @gateways = Pling::DelayedInitializer.new
   @middlewares = Pling::DelayedInitializer.new
   @adapter = Pling::Adapter::Base.new
+  @logger = Logger.new(nil)
 
   class Error < StandardError; end
   class AuthenticationFailed < Error; end
-  class DeliveryFailed < Error; end
   class NoGatewayFound < Error; end
 
+  class DeliveryFailed < Error
+    attr_reader :pling_message, :pling_device
+
+    def initialize(message = nil, pling_message = nil, pling_device = nil)
+      super(message)
+      @pling_message = pling_message
+      @pling_device  = pling_device
+    end
+  end
+
+
   class << self
     ##
     # Stores the list of available gateway instances
@@ -46,6 +60,12 @@ module Pling
     # @return [Pling::Adapter]
     attr_accessor :adapter
 
+    ##
+    # Stores the logger. Defaults to Logger.new(nil)
+    #
+    # @return [Logger]
+    attr_accessor :logger
+
     ##
     # Allows configuration of Pling by passing a config object to the given block
     #
@@ -66,6 +86,8 @@ module Pling
       message = Pling._convert(message, :message)
       device  = Pling._convert(device, :device)
 
+      Pling.logger.info "#{self.class} -- Delivering #{message.inspect} to #{device.inspect}"
+
       stack ||= middlewares.initialize! + [adapter]
 
       stack.shift.deliver(message, device) do |m, d|

data/pling.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = Pling::VERSION
   s.authors     = ["Benedikt Deicke", "Konstantin Tennhard", "Christian Bäuerlein"]
   s.email       = ["benedikt@synatic.net", "me@t6d.de", "fabrik42@gmail.com"]
-  s.homepage    = "https://flinc.github.com/pling"
+  s.homepage    = "http://flinc.github.com/pling"
   s.summary     = %q{Pling is a notification framework that supports multiple gateways}
   s.description = %q{Pling is a notification framework that supports multiple gateways. Currently supported are Android Push and SMS.}
 

data/spec/pling/apn/connection_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Pling::APN::Connection do
+
+  let(:configuration) do
+    {
+      :host => "localhost",
+      :port => 2195,
+      :certificate => "/path/to/certificate.pem"
+    }
+  end
+
+  let(:ssl_context)      { double(OpenSSL::SSL::SSLContext).as_null_object }
+  let(:x509_certificate) { double(OpenSSL::X509::Certificate).as_null_object }
+  let(:pkey_rsa)         { double(OpenSSL::PKey::RSA).as_null_object }
+  let(:tcp_socket)       { double(TCPSocket).as_null_object }
+  let(:ssl_socket)       { double(OpenSSL::SSL::SSLSocket, :closed? => false).as_null_object }
+
+  before do
+    File.stub(:read).and_return('')
+    OpenSSL::SSL::SSLContext.stub(:new).and_return(ssl_context)
+    OpenSSL::X509::Certificate.stub(:new).and_return(x509_certificate)
+    OpenSSL::PKey::RSA.stub(:new).and_return(pkey_rsa)
+    TCPSocket.stub(:new).and_return(tcp_socket)
+    OpenSSL::SSL::SSLSocket.stub(:new).and_return(ssl_socket)
+  end
+
+  context "when creating it from a valid configuration" do
+
+    it "should read the certificate" do
+      File.should_receive(:read).
+        with('/path/to/certificate.pem').
+        and_return("--- CERT CONTENT ---")
+    end
+
+    it "should create a tcp socket" do
+      TCPSocket.should_receive(:new).with("localhost", 2195)
+    end
+
+    it "should create a ssl socket" do
+      OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_context)
+    end
+
+    it "should create a ssl context" do
+      OpenSSL::SSL::SSLContext.should_receive(:new).and_return(ssl_context)
+      ssl_context.should_receive(:cert=).with(x509_certificate)
+      ssl_context.should_receive(:key=).with(pkey_rsa)
+    end
+
+    it "should connect the ssl socket" do
+      ssl_socket.should_receive(:connect)
+    end
+
+    after do
+      Pling::APN::Connection.new(configuration)
+    end
+
+  end
+
+  context 'when created with an invalid configuration' do
+
+    it "should raise an error when :certificate is missing" do
+      expect { Pling::APN::Connection.new({}) }.to raise_error(ArgumentError, /:certificate is missing/)
+    end
+
+  end
+
+  context "when writing data" do
+
+    subject do
+      Pling::APN::Connection.new(configuration)
+    end
+
+    it "should simply pass on the data to the underlying SSL socket" do
+      data = 'Pass this through!'
+      ssl_socket.should_receive(:write).with(data)
+      subject.write(data)
+    end
+    
+    it "should raise an exception it is closed" do
+      ssl_socket.stub(:closed? => true)
+      subject.close
+      expect { subject.write("Waahhhh!") }.to raise_error(IOError, "Connection closed")
+    end
+
+    it "should retry three times on Errno::EPIPE" do
+      ssl_socket.should_receive(:write).exactly(3).times.and_raise(Errno::EPIPE)
+      expect { subject.write("Whoops!") }.to raise_error(IOError)
+    end
+
+    it 'should reconnect between retries' do
+      ssl_socket.stub(:write).and_raise(Errno::EPIPE)
+      ssl_socket.should_receive(:connect).exactly(3).times
+      ssl_socket.should_receive(:close).exactly(2).times
+      expect { subject.write("Whoops!") }.to raise_error(IOError)
+    end
+
+  end
+
+  describe "#gets" do
+    subject do
+      Pling::APN::Connection.new(configuration)
+    end
+
+    it "should simply pass on the data" do
+      data = 'Pass this through!'
+      ssl_socket.should_receive(:gets).and_return(data)
+      subject.gets.should eq(data)
+    end
+  end
+
+  describe "#read" do
+    subject do
+      Pling::APN::Connection.new(configuration)
+    end
+
+    it "should simply pass on the data" do
+      data = 'Pass this through!'
+      ssl_socket.should_receive(:read).and_return(data)
+      subject.read.should eq(data)
+    end
+  end
+
+end

data/spec/pling/apn/feedback_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Pling::APN::Feedback do
+  
+  let(:connection) { double(Pling::APN::Connection, :closed? => false).as_null_object }
+  
+  let(:time) { Time.now.to_i }
+  
+  # Simulate device tokens of _different_ length! A device token is _not_
+  # necessarily 32 byte long. Check the documentation if you don't belive it. :)
+  # http://bit.ly/apple-apn-feedback-documentation
+  let(:token_0) { "0" * 64 }
+  let(:token_1) { "00000000000000000000000000000001" }
+  
+  let(:feedback_0) { [time, 32, token_0].pack("NnH*") }
+  let(:feedback_1) { [time, 16, token_1].pack("NnH*") }
+  
+  subject do
+    described_class.new(:certificate => '/path/to/certificate.pem')
+  end
+  
+  before do
+    Pling::APN::Connection.stub(:new).and_return(connection)
+    connection.stub(:gets).and_return(nil)
+  end
+
+  it { should respond_to(:get) }
+  
+  context "when getting feedback" do
+    
+    it "should be in form of a list" do
+      subject.get.should be_kind_of(Array)
+    end
+    
+    it "should contain all tokens send by Apple" do
+      connection.stub(:gets).and_return(feedback_0, feedback_1, nil)
+      tokens = subject.get
+      
+      tokens.should be == [token_0, token_1]
+    end
+    
+  end
+
+end

data/spec/pling/apn/gateway_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe Pling::APN::Gateway do
+
+  let(:valid_configuration) { { :certificate => '/path/to/certificate.pem' } }
+
+  let(:message) { Pling::Message.new('Hello from Pling') }
+
+  let(:device)  { Pling::Device.new(:identifier => '0' * 64, :type => :iphone) }
+
+  let(:connection) { double(Pling::APN::Connection).as_null_object }
+
+  before do
+    Pling::APN::Connection.stub(:new).and_return(connection)
+  end
+
+  it 'should handle various apn related device types' do
+    Pling::APN::Gateway.handled_types.should =~ [:apple, :apn, :ios, :ipad, :iphone, :ipod]
+  end
+
+  describe '#deliver' do
+    subject { Pling::APN::Gateway.new(valid_configuration) }
+
+    it 'should raise an error if no message is given' do
+      expect { subject.deliver(nil, device) }.to raise_error
+    end
+
+    it 'should raise an error the device is given' do
+      expect { subject.deliver(message, nil) }.to raise_error
+    end
+
+    it 'should call #to_pling_message on the given message' do
+      message.should_receive(:to_pling_message).and_return(message)
+      subject.deliver(message, device)
+    end
+
+    it 'should call #to_pling_device on the given device' do
+      device.should_receive(:to_pling_device).and_return(device)
+      subject.deliver(message, device)
+    end
+
+    it 'should raise an exception when the payload exceeds 256 bytes' do
+      message.body = "X" * 256
+      expect { subject.deliver(message, device) }.to raise_error(Pling::DeliveryFailed, /Payload size of \d+ exceeds allowed size of 256 bytes/)
+    end
+
+    it 'should try to deliver the given message' do
+      expected_header  = "\x00\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$"
+      expected_payload = {
+        'aps' => {
+          'alert' => 'Hello from Pling'
+        }
+      }
+
+      connection.stub(:write) do |packet|
+        header, payload = packet[0..36], packet[37..-1]
+        header.should eq(expected_header)
+        JSON.parse(payload).should eq(expected_payload)
+      end
+
+      subject.deliver(message, device)
+    end
+
+    it 'should include the given badge' do
+      expected_payload = {
+        'aps' => {
+          'alert' => 'Hello from Pling',
+          'badge' => 10
+        }
+      }
+
+      connection.stub(:write) do |packet|
+        JSON.parse(packet[37..-1]).should eq(expected_payload)
+      end
+
+      message.badge = 10
+
+      subject.deliver(message, device)
+    end
+
+    it 'should include the given badge' do
+      expected_payload = {
+        'aps' => {
+          'alert' => 'Hello from Pling',
+          'sound' => 'pling'
+        }
+      }
+
+      connection.stub(:write) do |packet|
+        JSON.parse(packet[37..-1]).should eq(expected_payload)
+      end
+
+      message.sound = :pling
+
+      subject.deliver(message, device)
+    end
+
+    context 'when configured to include payload' do
+      before do
+        valid_configuration.merge!(:payload => true)
+        message.payload = { :data => 'available' }
+      end
+
+      it 'should include the given payload' do
+        expected_payload = {
+          'aps' => {
+            'alert' => 'Hello from Pling'
+          },
+          'data' => 'available'
+        }
+
+        connection.stub(:write) do |packet|
+          JSON.parse(packet[37..-1]).should eq(expected_payload)
+        end
+
+        subject.deliver(message, device)
+      end
+    end
+
+    context 'when configured to not include payload' do
+      before do
+        valid_configuration.merge!(:payload => false)
+        message.payload = { :data => 'available' }
+      end
+
+      it 'should not include the given payload' do
+        expected_payload = {
+          'aps' => {
+            'alert' => 'Hello from Pling'
+          }
+        }
+
+        connection.stub(:write) do |packet|
+          JSON.parse(packet[37..-1]).should eq(expected_payload)
+        end
+
+        subject.deliver(message, device)
+      end
+    end
+  end
+end

data/spec/pling/{gateway/c2dm_spec.rb → c2dm/gateway_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Pling::Gateway::C2DM do
+describe Pling::C2DM::Gateway do
 
   let(:valid_configuration) do
     { :email => 'someone@gmail.com', :password => 'random', :source => 'some-source' }
@@ -28,12 +28,16 @@ describe Pling::Gateway::C2DM do
 
   before { Faraday.stub(:new).and_return(connection_mock) }
 
+  it 'should handle various apn related device types' do
+    Pling::C2DM::Gateway.handled_types.should =~ [:android, :c2dm]
+  end
+
   context 'when created with an invalid configuration' do
     [:email, :password, :source].each do |attribute|
       it "should raise an error when :#{attribute} is missing" do
         configuration = valid_configuration
         configuration.delete(attribute)
-        expect { Pling::Gateway::C2DM.new(configuration) }.to raise_error(ArgumentError, /:#{attribute} is missing/)
+        expect { Pling::C2DM::Gateway.new(configuration) }.to raise_error(ArgumentError, /:#{attribute} is missing/)
       end
     end
   end
@@ -52,7 +56,7 @@ describe Pling::Gateway::C2DM do
       end
 
       it 'should not raise an error' do
-        expect { Pling::Gateway::C2DM.new(valid_configuration) }.to_not raise_error
+        expect { Pling::C2DM::Gateway.new(valid_configuration) }.to_not raise_error
       end
 
       it 'should try to authenticate' do
@@ -60,31 +64,31 @@ describe Pling::Gateway::C2DM do
           with('https://www.google.com/accounts/ClientLogin', valid_authentication_params).
           and_return(authentication_response_mock)
 
-        Pling::Gateway::C2DM.new(valid_configuration)
+        Pling::C2DM::Gateway.new(valid_configuration)
       end
 
       it 'should extract the token from the response body' do
-        gateway = Pling::Gateway::C2DM.new(valid_configuration)
+        gateway = Pling::C2DM::Gateway.new(valid_configuration)
         gateway.token.should eq('S0ME-ToKeN123')
       end
 
       it 'should raise an error if authentication was not successful' do
         authentication_response_mock.stub(:status => 403, :success? => false, :body => 'Error=BadAuthentication')
 
-        expect { Pling::Gateway::C2DM.new(valid_configuration) }.to raise_error(Pling::AuthenticationFailed, /Authentication failed: \[403\] Error=BadAuthentication/)
+        expect { Pling::C2DM::Gateway.new(valid_configuration) }.to raise_error(Pling::AuthenticationFailed, /Authentication failed: \[403\] Error=BadAuthentication/)
       end
 
       it 'should raise an error if it could not extract a token from the response' do
         authentication_response_mock.stub(:body).and_return('SOMERANDOMBODY')
 
-        expect { Pling::Gateway::C2DM.new(valid_configuration) }.to raise_error(Pling::AuthenticationFailed, /Token extraction failed/)
+        expect { Pling::C2DM::Gateway.new(valid_configuration) }.to raise_error(Pling::AuthenticationFailed, /Token extraction failed/)
       end
     end
 
     context 'configuration' do
       it 'should allow configuring Faraday\'s :connection settings' do
         Faraday.should_receive(:new).with(:ssl => { :verify => false })
-        Pling::Gateway::C2DM.new(valid_configuration.merge(:connection => { :ssl => { :verify => false }}))
+        Pling::C2DM::Gateway.new(valid_configuration.merge(:connection => { :ssl => { :verify => false }}))
       end
 
       it 'should use Faraday::Response::Logger when :debug is set to true' do
@@ -92,7 +96,7 @@ describe Pling::Gateway::C2DM do
         builder.should_receive(:use).with(Faraday::Response::Logger)
         Faraday.stub(:new).and_yield(builder).and_return(connection_mock)
 
-        Pling::Gateway::C2DM.new(valid_configuration.merge(:debug => true))
+        Pling::C2DM::Gateway.new(valid_configuration.merge(:debug => true))
       end
 
       it 'should use the adapter set with :adapter' do
@@ -100,7 +104,7 @@ describe Pling::Gateway::C2DM do
         builder.should_receive(:adapter).with(:typheus)
         Faraday.stub(:new).and_yield(builder).and_return(connection_mock)
 
-        Pling::Gateway::C2DM.new(valid_configuration.merge(:adapter => :typheus))
+        Pling::C2DM::Gateway.new(valid_configuration.merge(:adapter => :typheus))
       end
 
       it 'should allow configuring the authentication_url' do
@@ -108,13 +112,13 @@ describe Pling::Gateway::C2DM do
           with('http://example.com/authentication', anything).
           and_return(authentication_response_mock)
 
-        Pling::Gateway::C2DM.new(valid_configuration.merge(:authentication_url => 'http://example.com/authentication'))
+        Pling::C2DM::Gateway.new(valid_configuration.merge(:authentication_url => 'http://example.com/authentication'))
       end
     end
   end
 
   describe '#deliver' do
-    subject { Pling::Gateway::C2DM.new(valid_configuration) }
+    subject { Pling::C2DM::Gateway.new(valid_configuration) }
 
     let(:message) { Pling::Message.new('Hello from Pling') }
     let(:device)  { Pling::Device.new(:identifier => 'DEVICEIDENTIFIER', :type => :android) }
@@ -160,23 +164,78 @@ describe Pling::Gateway::C2DM do
     end
 
     it 'should raise a Pling::DeliveryFailed exception if the delivery was not successful' do
-      connection_mock.should_receive(:post).
-        with('https://android.apis.google.com/c2dm/send', valid_push_params, valid_push_headers).
-        and_return(push_response_mock)
-
+      connection_mock.should_receive(:post).and_return(push_response_mock)
       push_response_mock.stub(:status => 401, :success? => false, :body => "Something went wrong")
 
       expect { subject.deliver(message, device) }.to raise_error Pling::DeliveryFailed, /Something went wrong/
     end
 
     it 'should raise a Pling::DeliveryFailed exception if the response body contained an error' do
+      connection_mock.should_receive(:post).and_return(push_response_mock)
+      push_response_mock.stub(:status => 200, :success? => true, :body => "Error=SomeError")
+
+      expect { subject.deliver(message, device) }.to raise_error Pling::DeliveryFailed, /Error=SomeError/
+    end
+
+    it 'should send data.badge if the given message has a badge' do
       connection_mock.should_receive(:post).
-        with('https://android.apis.google.com/c2dm/send', valid_push_params, valid_push_headers).
+        with(anything, hash_including(:'data.badge' => '10'), anything).
         and_return(push_response_mock)
+      message.badge = 10
+      subject.deliver(message, device)
+    end
 
-      push_response_mock.stub(:status => 200, :success? => true, :body => "Error=SomeError")
+    it 'should send data.sound if the given message has a sound' do
+      connection_mock.should_receive(:post).
+        with(anything, hash_including(:'data.sound' => 'pling'), anything).
+        and_return(push_response_mock)
+      message.sound = :pling
+      subject.deliver(message, device)
+    end
 
-      expect { subject.deliver(message, device) }.to raise_error Pling::DeliveryFailed, /Error=SomeError/
+    it 'should send data.subject if the given message has a subject' do
+      connection_mock.should_receive(:post).
+        with(anything, hash_including(:'data.subject' => 'Important!'), anything).
+        and_return(push_response_mock)
+      message.subject = 'Important!'
+      subject.deliver(message, device)
+    end
+
+    context 'when configured to include payload' do
+      before do
+        valid_configuration.merge!(:payload => true)
+        message.payload = { :data => 'available' }
+      end
+
+      it 'should include the given payload' do
+        connection_mock.should_receive(:post).
+          with(anything, hash_including(:'data.data' => 'available'), anything).
+          and_return(push_response_mock)
+        subject.deliver(message, device)
+      end
+    end
+
+    context 'when configured to not include payload' do
+      before do
+        valid_configuration.merge!(:payload => false)
+        message.payload = { :data => 'available' }
+      end
+
+      it 'should include the given payload' do
+        connection_mock.should_receive(:post).
+          with(anything, hash_not_including(:'data.data' => 'available'), anything).
+          and_return(push_response_mock)
+        subject.deliver(message, device)
+      end
+    end
+
+    [:QuotaExceeded, :DeviceQuotaExceeded,
+     :InvalidRegistration, :NotRegistered,
+     :MessageTooBig, :MissingCollapseKey].each do |exception|
+      it "should raise a Pling::C2DM::#{exception} when the response body is ''" do
+        push_response_mock.stub(:body => "Error=#{exception}")
+        expect { subject.deliver(message, device) }.to raise_error Pling::C2DM.const_get(exception)
+      end
     end
   end
-end
+end