pling 0.0.1 → 0.1.0

data/spec/pling/gateway/apn_spec.rb

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,61 @@
+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

data/spec/pling/gateway/c2dm_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Pling::Gateway::C2DM do
+
+  let(:valid_configuration) do
+    { :email => 'someone@gmail.com', :password => 'random', :source => 'some-source' }
+  end
+
+  let(:authentication_response_mock) do
+    mock('Faraday authentication response', :success? => true, :status => 200, :body => "SID=SOMESID\nAuth=S0ME-ToKeN123")
+  end
+
+  let(:push_response_mock) do
+    mock('Faraday send response', :success? => true, :status => 200, :body => "")
+  end
+
+  let(:connection_mock) do
+    mock('Faraday connection').tap do |mock|
+      mock.stub(:post).
+        with('https://www.google.com/accounts/ClientLogin', anything).
+        and_return(authentication_response_mock)
+
+      mock.stub(:post).
+        with('https://android.apis.google.com/c2dm/send', anything, anything).
+        and_return(push_response_mock)
+    end
+  end
+
+  before { Faraday.stub(:new).and_return(connection_mock) }
+
+  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/)
+      end
+    end
+  end
+
+  context 'when created with valid configuration' do
+
+    context 'authenticating' do
+      let(:valid_authentication_params) do
+        {
+          :accountType => 'HOSTED_OR_GOOGLE',
+          :service => 'ac2dm',
+          :Email => valid_configuration[:email],
+          :Passwd => valid_configuration[:password],
+          :source => valid_configuration[:source]
+        }
+      end
+
+      it 'should not raise an error' do
+        expect { Pling::Gateway::C2DM.new(valid_configuration) }.to_not raise_error
+      end
+
+      it 'should try to authenticate' do
+        connection_mock.should_receive(:post).
+          with('https://www.google.com/accounts/ClientLogin', valid_authentication_params).
+          and_return(authentication_response_mock)
+
+        Pling::Gateway::C2DM.new(valid_configuration)
+      end
+
+      it 'should extract the token from the response body' do
+        gateway = Pling::Gateway::C2DM.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/)
+      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/)
+      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 }}))
+      end
+
+      it 'should use Faraday::Response::Logger when :debug is set to true' do
+        builder = mock(:use => true, :adapter => true)
+        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))
+      end
+
+      it 'should use the adapter set with :adapter' do
+        builder = mock(:use => true, :adapter => true)
+        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))
+      end
+
+      it 'should allow configuring the authentication_url' do
+        connection_mock.should_receive(:post).
+          with('http://example.com/authentication', anything).
+          and_return(authentication_response_mock)
+
+        Pling::Gateway::C2DM.new(valid_configuration.merge(:authentication_url => 'http://example.com/authentication'))
+      end
+    end
+  end
+
+  describe '#deliver' do
+    subject { Pling::Gateway::C2DM.new(valid_configuration) }
+
+    let(:message) { Pling::Message.new('Hello from Pling') }
+    let(:device)  { Pling::Device.new(:identifier => 'DEVICEIDENTIFIER', :type => :android) }
+
+    let(:valid_push_params) do
+      {
+        :registration_id => device.identifier,
+        :'data.body' => message.body,
+        :collapse_key => message.body.hash
+      }
+    end
+
+    let(:valid_push_headers) do
+      {
+        :Authorization => 'GoogleLogin auth=S0ME-ToKeN123'
+      }
+    end
+
+    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 try to deliver the given message' 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)
+
+      subject.deliver(message, device)
+    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)
+
+      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).
+        with('https://android.apis.google.com/c2dm/send', valid_push_params, valid_push_headers).
+        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
+  end
+end

data/spec/pling/gateway_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Pling::Gateway do
+
+  subject { Pling::Gateway }
+
+  let(:message) { Pling::Message.new('Hello from Pling') }
+  let(:device)  { Pling::Device.new(:identifier => 'DEVICEIDENTIFIER', :type => :android) }
+
+  let(:gateway_class) do
+    Class.new(Pling::Gateway::Base).tap do |klass|
+      klass.instance_eval do
+        handles :android
+      end
+    end
+  end
+
+  let(:gateway) { gateway_class.new }
+
+  before { Pling.stub(:gateways).and_return(Pling::DelayedInitializer.new([gateway])) }
+
+  it { should respond_to(:discover) }
+
+  describe '.discover' do
+    it 'should do a delayed initialization' do
+      Pling.stub(:gateways).and_return(Pling::DelayedInitializer.new([[gateway_class, { :some => :option }]]))
+      gateway_class.should_receive(:new).with({ :some => :option }).and_return(mock.as_null_object)
+      subject.discover(device)
+    end
+
+    it 'should require an argument' do
+      expect { subject.discover }.to raise_error ArgumentError
+    end
+
+    it 'should call #to_pling_device on the given argument' do
+      device.should_receive(:to_pling_device).and_return(device)
+      subject.discover(device)
+    end
+
+    it 'should return a gateway that can handle the given device' do
+      subject.discover(device).should be == gateway
+    end
+
+    it 'should raise an Pling::NoGatewayFound error if no gateway was found' do
+      device.type = :random
+      expect { subject.discover(device) }.to raise_error Pling::NoGatewayFound, /Could not find a gateway for Pling::Device with type :random/
+    end
+  end
+
+end

data/spec/pling/message_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Pling::Message do
+
+  context 'when created with no arguments' do
+    it 'should not require an argument' do
+      expect { Pling::Message.new() }.to_not raise_error ArgumentError
+    end
+
+    specify { Pling::Message.new().should_not be_valid }
+  end
+
+  context 'when created with a string as first argument' do
+    subject { Pling::Message.new('Hello from Pling') }
+    its(:body) { should eq('Hello from Pling') }
+    it { should be_valid }
+  end
+
+  context 'when created with a hash that contains a :body key as first argument' do
+    subject { Pling::Message.new(:body => 'Hello from Pling') }
+    its(:body) { should eq('Hello from Pling') }
+    it { should be_valid }
+  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
+    end
+  end
+
+  describe '#body=' do
+    it 'should call #to_s on the given body' do
+      subject.body = stub(:to_s => 'Hello from Pling')
+      subject.body.should eq('Hello from Pling')
+    end
+  end
+
+  describe '#to_pling_message' do
+    it 'should return self' do
+      subject.to_pling_message.should be === subject
+    end
+  end
+
+end

data/spec/pling_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Pling do
+
+  subject { Pling }
+
+  it { should respond_to(:configure) }
+
+  describe '.configure' do
+    it 'should require a block' do
+      expect { subject.configure }.to raise_error(ArgumentError, /no block given/i)
+    end
+
+    it 'should call the block' do
+      expect { Pling.configure { throw :executed } }.to throw_symbol(:executed)
+    end
+
+    it 'should pass Pling to the block' do
+      Pling.configure do |config|
+        config.should be(Pling)
+      end
+    end
+  end
+
+  it { should respond_to(:gateways) }
+  it { should respond_to(:gateways=) }
+  its(:gateways) { should eq([]) }
+  its(:gateways) { should be_kind_of Pling::DelayedInitializer }
+
+  describe '.gateways=' do
+    it 'should not change its type when set to an other array' do
+      subject.gateways = []
+      subject.gateways.should be_kind_of Pling::DelayedInitializer
+    end
+  end
+
+  it { should respond_to(:middlewares) }
+  it { should respond_to(:middlewares=) }
+  its(:middlewares) { should eq([]) }
+  its(:middlewares) { should be_kind_of Pling::DelayedInitializer }
+
+  describe '.middlewares=' do
+    it 'should not change its type when set to an other array' do
+      subject.middlewares = []
+      subject.middlewares.should be_kind_of Pling::DelayedInitializer
+    end
+  end
+
+  it { should respond_to(:adapter) }
+  it { should respond_to(:adapter=) }
+
+  describe '.adapter' do
+    it 'should default to Pling::Adapter::Base' do
+      subject.adapter.class.should eq(Pling::Adapter::Base)
+    end
+  end
+
+  describe '.deliver' do
+
+    let(:message) { Pling::Message.new }
+    let(:device)  { Pling::Device.new  }
+    let(:adapter) { mock(:deliver => true) }
+
+    before do
+      Pling.stub(:adapter).and_return(adapter)
+    end
+
+    it 'should raise an error if no message is given' do
+      expect { Pling.deliver(nil, device) }.to raise_error
+    end
+
+    it 'should raise an error the device is given' do
+      expect { Pling.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)
+      Pling.deliver(message, device)
+    end
+
+    it 'should call #to_pling_device on the given device' do
+      device.should_receive(:to_pling_device).and_return(device)
+      Pling.deliver(message, device)
+    end
+
+    it 'should call the adapter' do
+      adapter.should_receive(:deliver).with(message, device)
+      Pling.deliver(message, device)
+    end
+
+    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)
+
+      Pling.stub(:middlewares).and_return(Pling::DelayedInitializer.new([first_middleware, second_middleware]))
+
+      Pling.deliver(message, device)
+    end
+  end
+end
+
+describe Pling::AuthenticationFailed do
+  it { should be_kind_of Pling::Error }
+end
+
+describe Pling::DeliveryFailed do
+  it { should be_kind_of Pling::Error }
+end
+
+describe Pling::NoGatewayFound do
+  it { should be_kind_of Pling::Error }
+end