pling 0.1.0 → 0.2.0

data/spec/pling/gateway_spec.rb

@@ -8,9 +8,9 @@ describe Pling::Gateway do
   let(:device)  { Pling::Device.new(:identifier => 'DEVICEIDENTIFIER', :type => :android) }
 
   let(:gateway_class) do
-    Class.new(Pling::Gateway::Base).tap do |klass|
+    Class.new(Pling::Gateway).tap do |klass|
       klass.instance_eval do
-        handles :android
+        handles :android, :c2dm
       end
     end
   end
@@ -33,7 +33,7 @@ describe Pling::Gateway do
     end
 
     it 'should call #to_pling_device on the given argument' do
-      device.should_receive(:to_pling_device).and_return(device)
+      device.should_receive(:to_pling_device).at_least(1).times.and_return(device)
       subject.discover(device)
     end
 
@@ -47,4 +47,66 @@ describe Pling::Gateway do
     end
   end
 
+  describe '#handles?' do
+    it 'should return true if the gateway supports the given device\'s type' do
+      device.type = :android
+      gateway.handles?(device).should be_true
+
+      device.type = :c2dm
+      gateway.handles?(device).should be_true
+    end
+
+    it 'should return false if the gateway does not support the given device\'s type' do
+      device.type = :random
+      gateway.handles?(device).should be_false
+    end
+  end
+
+  describe '#deliver' do
+
+    it 'should call each middleware in the given order' do
+      first_middleware = double(Pling::Middleware::Base)
+      first_middleware.should_receive(:deliver).
+        with(message, device).and_yield(message, device)
+
+      second_middleware = double(Pling::Middleware::Base)
+      second_middleware.should_receive(:deliver).
+        with(message, device)
+
+      gateway = gateway_class.new(:middlewares => [first_middleware, second_middleware])
+      gateway.stub(:deliver!)
+
+      gateway.deliver(message, device)
+    end
+
+    it 'should raise an error if #deliver! is not overwritten' do
+      expect { gateway.deliver(message, device) }.to raise_error(/Please implement/)
+    end
+
+    it 'should not modify the middleware configuration' do
+      middlewares = [Pling::Middleware::Base.new, Pling::Middleware::Base.new]
+
+      gateway = gateway_class.new(:middlewares => middlewares)
+      gateway.stub(:deliver!)
+
+      expect { gateway.deliver(message, device) }.to_not change(middlewares, :count)
+    end
+
+    it 'should raise an Pling::Errors if no on_exception callback is set' do
+      gateway.stub(:deliver!).and_raise(Pling::Error)
+      expect { gateway.deliver(message, device) }.to raise_error Pling::Error
+    end
+
+    it 'should not raise an Pling::Errors if an on_exception callback is set' do
+      gateway = gateway_class.new(:on_exception => lambda {})
+      gateway.stub(:deliver!).and_raise(Pling::Error)
+      expect { gateway.deliver(message, device) }.to_not raise_error Pling::Error
+    end
+
+    it 'should pass the exception to the callback' do
+      gateway = gateway_class.new(:on_exception => lambda { |error| error.should be_kind_of Pling::Error })
+      gateway.stub(:deliver!).and_raise(Pling::Error)
+      gateway.deliver(message, device)
+    end
+  end
 end

data/spec/pling/message_spec.rb

@@ -22,6 +22,31 @@ describe Pling::Message do
     it { should be_valid }
   end
 
+  context 'when created with a hash that contains a :subject key' do
+    subject { Pling::Message.new(:subject => "Hello!")}
+    its(:subject) { should eq('Hello!')}
+  end
+
+  context 'when created with a hash that contains a :badge key' do
+    subject { Pling::Message.new(:badge => 1)}
+    its(:badge) { should eq('1') }
+  end
+
+  context 'when created with a hash that contains a :sound key' do
+    subject { Pling::Message.new(:sound => '*pling*')}
+    its(:sound) { should eq('*pling*') }
+  end
+
+  context 'when created with a hash that contains a :badge key' do
+    subject { Pling::Message.new(:badge => 1)}
+    its(:badge) { should eq('1') }
+  end
+
+  context 'when created with a hash that contains a :payload key' do
+    subject { Pling::Message.new(:payload => { :data => true })}
+    its(:payload) { should eq({ :data => true }) }
+  end
+
   context 'when created with an hash of invalid attributes' do
     it 'should ignore the invalid paramters' do
       expect { Pling::Message.new({ :random_param => true }) }.to_not raise_error

data/spec/pling_spec.rb

@@ -110,6 +110,15 @@ end
 
 describe Pling::DeliveryFailed do
   it { should be_kind_of Pling::Error }
+  it { should respond_to :pling_message }
+  it { should respond_to :pling_device }
+
+  it 'should initialize #pling_message and #pling_device' do
+    error = Pling::DeliveryFailed.new('message', 'pling message', 'pling device')
+    error.message.should eq('message')
+    error.pling_message.should eq('pling message')
+    error.pling_device.should eq('pling device')
+  end
 end
 
 describe Pling::NoGatewayFound do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pling
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,11 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-28 00:00:00.000000000Z
+date: 2011-11-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
-  requirement: &70095758683660 !ruby/object:Gem::Requirement
+  requirement: &70316014249500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -23,10 +23,10 @@ dependencies:
         version: '0.7'
   type: :runtime
   prerelease: false
-  version_requirements: *70095758683660
+  version_requirements: *70316014249500
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &70095758682420 !ruby/object:Gem::Requirement
+  requirement: &70316014248240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -34,10 +34,10 @@ dependencies:
         version: '1.4'
   type: :runtime
   prerelease: false
-  version_requirements: *70095758682420
+  version_requirements: *70316014248240
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70095758681540 !ruby/object:Gem::Requirement
+  requirement: &70316014247280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -45,10 +45,10 @@ dependencies:
         version: '2.7'
   type: :development
   prerelease: false
-  version_requirements: *70095758681540
+  version_requirements: *70316014247280
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &70095758680240 !ruby/object:Gem::Requirement
+  requirement: &70316014246260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -56,10 +56,10 @@ dependencies:
         version: '0.7'
   type: :development
   prerelease: false
-  version_requirements: *70095758680240
+  version_requirements: *70316014246260
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70095758678900 !ruby/object:Gem::Requirement
+  requirement: &70316014245540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,7 +67,7 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *70095758678900
+  version_requirements: *70316014245540
 description: Pling is a notification framework that supports multiple gateways. Currently
   supported are Android Push and SMS.
 email:
@@ -88,29 +88,35 @@ files:
 - lib/pling.rb
 - lib/pling/adapter.rb
 - lib/pling/adapter/base.rb
+- lib/pling/apn.rb
+- lib/pling/apn/connection.rb
+- lib/pling/apn/feedback.rb
+- lib/pling/apn/gateway.rb
+- lib/pling/c2dm.rb
+- lib/pling/c2dm/gateway.rb
 - lib/pling/configurable.rb
 - lib/pling/delayed_initializer.rb
 - lib/pling/device.rb
 - lib/pling/gateway.rb
-- lib/pling/gateway/apn.rb
-- lib/pling/gateway/base.rb
-- lib/pling/gateway/c2dm.rb
 - lib/pling/message.rb
 - lib/pling/middleware.rb
 - lib/pling/middleware/base.rb
 - lib/pling/version.rb
 - pling.gemspec
+- spec/pling/.DS_Store
+- spec/pling/adapter/.DS_Store
 - spec/pling/adapter/base_spec.rb
+- spec/pling/apn/connection_spec.rb
+- spec/pling/apn/feedback_spec.rb
+- spec/pling/apn/gateway_spec.rb
+- spec/pling/c2dm/gateway_spec.rb
 - spec/pling/delayed_initializer_spec.rb
 - spec/pling/device_spec.rb
-- spec/pling/gateway/apn_spec.rb
-- spec/pling/gateway/base_spec.rb
-- spec/pling/gateway/c2dm_spec.rb
 - spec/pling/gateway_spec.rb
 - spec/pling/message_spec.rb
 - spec/pling_spec.rb
 - spec/spec_helper.rb
-homepage: https://flinc.github.com/pling
+homepage: http://flinc.github.com/pling
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -135,12 +141,15 @@ signing_key:
 specification_version: 3
 summary: Pling is a notification framework that supports multiple gateways
 test_files:
+- spec/pling/.DS_Store
+- spec/pling/adapter/.DS_Store
 - spec/pling/adapter/base_spec.rb
+- spec/pling/apn/connection_spec.rb
+- spec/pling/apn/feedback_spec.rb
+- spec/pling/apn/gateway_spec.rb
+- spec/pling/c2dm/gateway_spec.rb
 - spec/pling/delayed_initializer_spec.rb
 - spec/pling/device_spec.rb
-- spec/pling/gateway/apn_spec.rb
-- spec/pling/gateway/base_spec.rb
-- spec/pling/gateway/c2dm_spec.rb
 - spec/pling/gateway_spec.rb
 - spec/pling/message_spec.rb
 - spec/pling_spec.rb

data/lib/pling/gateway/base.rb

@@ -1,64 +0,0 @@
-module Pling
-  module Gateway
-    class Base
-      include Pling::Configurable
-
-      class << self
-        def handles(*types)
-          @handled_types = [types].flatten.map { |t| t.to_sym }
-        end
-
-        def handled_types
-          @handled_types ||= []
-        end
-      end
-
-      def initialize(config = {})
-        setup_configuration(config)
-        middlewares = configuration[:middlewares]
-        configuration.merge!(:middlewares => Pling::DelayedInitializer.new)
-        middlewares.each { |middleware| configuration[:middlewares] << middleware } if middlewares
-      end
-
-      def handles?(device)
-        self.class.handled_types.include?(device.type)
-      end
-
-      ##
-      # Delivers the given message to the given device using the given stack.
-      #
-      # @param message [#to_pling_message]
-      # @param device [#to_pling_device]
-      # @param stack [Array] The stack to use (Default: configuration[:middlewares])
-      def deliver(message, device, stack = nil)
-        message = Pling._convert(message, :message)
-        device  = Pling._convert(device,  :device)
-
-        stack ||= [] + configuration[:middlewares].initialize!
-
-        return deliver!(message, device) if stack.empty?
-
-        stack.shift.deliver(message, device) do |m, d|
-          deliver(m, d, stack)
-        end
-      end
-
-      ##
-      # Delivers the given message to the given device without using the middleware.
-      #
-      # @param message [#to_pling_message]
-      # @param device [#to_pling_device]
-      def deliver!(message, device)
-        raise NotImplementedError, "Please implement #{self.class}#deliver!(message, device)"
-      end
-
-      protected
-
-        def default_configuration
-          {
-            :middlewares => Pling::DelayedInitializer.new
-          }
-        end
-    end
-  end
-end

data/spec/pling/gateway/apn_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe Pling::Gateway::APN do
-
-  let(:valid_configuration) { { :certificate => '/path/to/certificate.pem' } }
-
-  let(:message) { Pling::Message.new('Hello from Pling') }
-  let(:device)  { Pling::Device.new(:identifier => 'DEVICEIDENTIFIER', :type => :iphone) }
-
-  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).as_null_object }
-
-  before do
-    File.stub(:read).with('/path/to/certificate.pem').and_return('--- CERT CONTENT ---')
-    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
-
-  it 'should handle various apn related device types' do
-    Pling::Gateway::APN.handled_types.should =~ [:apple, :apn, :ios, :ipad, :iphone, :ipod]
-  end
-
-  context 'when created with an invalid configuration' do
-    it "should raise an error when :certificate is missing" do
-      expect { Pling::Gateway::APN.new({}) }.to raise_error(ArgumentError, /:certificate is missing/)
-    end
-  end
-
-  context 'when created with a valid configuration' do
-    it 'should allow configuration of the :certificate' do
-      File.should_receive(:read).with('/some/path').and_return('--- SOME CERT CONTENT ---')
-      gateway = Pling::Gateway::APN.new(valid_configuration.merge(:certificate => '/some/path'))
-      gateway.deliver(message, device)
-    end
-
-    it 'should allow configuration of the :host' do
-      TCPSocket.should_receive(:new).with('some-host', anything).and_return(tcp_socket)
-      gateway = Pling::Gateway::APN.new(valid_configuration.merge(:host => 'some-host'))
-      gateway.deliver(message, device)
-    end
-
-    it 'should allow configuration of the :port' do
-      TCPSocket.should_receive(:new).with(anything, 1234).and_return(tcp_socket)
-      gateway = Pling::Gateway::APN.new(valid_configuration.merge(:port => 1234))
-      gateway.deliver(message, device)
-    end
-
-    it 'should establish a connection' do
-      ssl_socket.should_receive(:connect)
-      Pling::Gateway::APN.new(valid_configuration)
-    end
-  end
-
-  describe '#deliver' do
-    subject { Pling::Gateway::APN.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 \xDE\xF2\xCE-\xE7\xD2\xF2\xEB\x00"
-      expected_payload = {
-        'aps' => {
-          'alert' => 'Hello from Pling'
-        }
-      }
-
-      ssl_socket.stub(:write) do |packet|
-        header, payload = packet.split('$')
-        header.should eq(expected_header)
-        JSON.parse(payload).should eq(expected_payload)
-      end
-
-      subject.deliver(message, device)
-    end
-  end
-end

data/spec/pling/gateway/base_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Pling::Gateway::Base do
-
-  let(:gateway_class) do
-    Class.new(Pling::Gateway::Base).tap do |klass|
-      klass.handles :android, :c2dm
-    end
-  end
-
-  let(:gateway) { gateway_class.new }
-  let(:message) { Pling::Message.new }
-  let(:device) { Pling::Device.new }
-
-  describe '#handles?' do
-    it 'should return true if the gateway supports the given device\'s type' do
-      device.type = :android
-      gateway.handles?(device).should be_true
-
-      device.type = :c2dm
-      gateway.handles?(device).should be_true
-    end
-
-    it 'should return false if the gateway does not support the given device\'s type' do
-      device.type = :random
-      gateway.handles?(device).should be_false
-    end
-  end
-
-  describe '#deliver' do
-
-    it 'should call each middleware in the given order' do
-      first_middleware = double(Pling::Middleware::Base)
-      first_middleware.should_receive(:deliver).
-        with(message, device).and_yield(message, device)
-
-      second_middleware = double(Pling::Middleware::Base)
-      second_middleware.should_receive(:deliver).
-        with(message, device)
-
-      gateway = gateway_class.new(:middlewares => [first_middleware, second_middleware])
-      gateway.stub(:deliver!)
-
-      gateway.deliver(message, device)
-    end
-
-    it 'should raise an error if #deliver! is not overwritten' do
-      expect { gateway.deliver(message, device) }.to raise_error(/Please implement/)
-    end
-
-    it 'should not modify the middleware configuration' do
-      middlewares = [Pling::Middleware::Base.new, Pling::Middleware::Base.new]
-
-      gateway = gateway_class.new(:middlewares => middlewares)
-      gateway.stub(:deliver!)
-
-      expect { gateway.deliver(message, device) }.to_not change(middlewares, :count)
-    end
-  end
-
-end