ruby-push-notifications 0.0.1

data/lib/ruby-push-notifications/gcm.rb

@@ -0,0 +1,7 @@
+require 'ruby-push-notifications/gcm/gcm_connection'
+require 'ruby-push-notifications/gcm/gcm_notification'
+require 'ruby-push-notifications/gcm/gcm_pusher'
+require 'ruby-push-notifications/gcm/gcm_response'
+require 'ruby-push-notifications/gcm/gcm_error'
+require 'ruby-push-notifications/gcm/gcm_result'
+

data/lib/ruby-push-notifications/gcm/gcm_connection.rb

@@ -0,0 +1,31 @@
+require 'uri'
+require 'net/https'
+
+module RubyPushNotifications
+  module GCM
+    class GCMConnection
+
+      GCM_URL = 'https://android.googleapis.com/gcm/send'
+
+      CONTENT_TYPE_HEADER  = 'Content-Type'
+      JSON_CONTENT_TYPE    = 'application/json'
+      AUTHORIZATION_HEADER = 'Authorization'
+
+      def self.post(notification, key)
+        headers = {
+            CONTENT_TYPE_HEADER => JSON_CONTENT_TYPE,
+            AUTHORIZATION_HEADER => "key=#{key}"
+        }
+
+        url = URI.parse GCM_URL
+        http = Net::HTTP.new url.host, url.port
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        response = http.post url.path, notification, headers
+
+        GCMResponse.new response.code.to_i, response.body
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_error.rb

@@ -0,0 +1,14 @@
+
+module RubyPushNotifications
+  module GCM
+    class GCMError < StandardError ; end
+
+    class MalformedGCMJSONError < GCMError ; end
+
+    class GCMAuthError < GCMError ; end
+
+    class GCMInternalError < GCMError ; end
+
+    class UnexpectedGCMResponseError < GCMError ; end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_notification.rb

@@ -0,0 +1,21 @@
+
+module RubyPushNotifications
+  module GCM
+    class GCMNotification
+
+      attr_accessor :results
+
+      def initialize(registration_ids, data)
+        @registration_ids = registration_ids
+        @data = data
+      end
+
+      def as_gcm_json
+        JSON.dump(
+          registration_ids: @registration_ids,
+          data: @data
+        )
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_pusher.rb

@@ -0,0 +1,17 @@
+
+module RubyPushNotifications
+  module GCM
+    class GCMPusher
+
+      def initialize(key)
+        @key = key
+      end
+
+      def push(notifications)
+        notifications.each do |notif|
+          notif.results = GCMConnection.post notif.as_gcm_json, @key
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_response.rb

@@ -0,0 +1,52 @@
+
+module RubyPushNotifications
+  module GCM
+    class GCMResponse
+
+      attr_reader :success, :failed, :canonical_ids, :results
+
+      def initialize(code, body)
+        case code
+        when 200
+          parse_response body
+        when 400
+          raise MalformedGCMJSONError, body
+        when 401
+          raise GCMAuthError, body
+        when 500..599
+          raise GCMInternalError, body
+        else
+          raise UnexpectedGCMResponseError, code
+        end
+      end
+
+      def ==(other)
+        (other.is_a?(GCMResponse) &&
+          success == other.success &&
+          failed == other.failed &&
+          canonical_ids == other.canonical_ids &&
+          results == other.results) || super(other)
+      end
+
+      private
+
+      def parse_response(body)
+        json = JSON.parse body, symbolize_names: true
+        @success = json[:success]
+        @failed = json[:failure]
+        @canonical_ids = json[:canonical_ids]
+        @results = (json[:results] || []).map { |result| gcm_result_for result }
+      end
+
+      def gcm_result_for(result)
+        if canonical_id = result[:registration_id]
+          GCMCanonicalIDResult.new canonical_id
+        elsif error = result[:error]
+          GCMResultError.new error
+        else
+          GCMResultOK.new
+        end
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/gcm/gcm_result.rb

@@ -0,0 +1,38 @@
+
+module RubyPushNotifications
+  module GCM
+    class GCMResult ; end
+
+    class GCMResultOK < GCMResult
+
+      def ==(other)
+        other.is_a?(GCMResultOK) || super(other)
+      end
+    end
+
+    class GCMCanonicalIDResult < GCMResult
+      attr_reader :canonical_id
+
+      def initialize(canonical_id)
+        @canonical_id = canonical_id
+      end
+
+      def ==(other)
+        (other.is_a?(GCMCanonicalIDResult) && @canonical_id == other.canonical_id) ||
+        super(other)
+      end
+    end
+
+    class GCMResultError < GCMResult
+      attr_accessor :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def ==(other)
+        (other.is_a?(GCMResultError) && @error == other.error) || super(other)
+      end
+    end
+  end
+end

data/lib/ruby-push-notifications/version.rb

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

data/ruby-push-notifications.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-push-notifications/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-push-notifications"
+  spec.version       = RubyPushNotifications::VERSION
+  spec.authors       = ['Carlos Alonso']
+  spec.email         = ['info@mrcalonso.com']
+  spec.summary       = %q{iOS and Android Push Notifications made easy!}
+  spec.description   = %q{Easy to use gem to send iOS and Android Push notifications}
+  spec.homepage      = 'https://github.com/calonso/ruby-push-notifications'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'factory_girl', '~> 4.0'
+  spec.add_development_dependency 'webmock', '~> 1.20'
+end

data/spec/factories.rb

@@ -0,0 +1,10 @@
+
+FactoryGirl.define do
+  sequence :apns_token do |i|
+    "ce8be627 2e43e855 16033e24 b4c28922 0eeda487 9c477160 b2545e95 b68b596#{i}"
+  end
+
+  sequence :gcm_registration_id do |i|
+    "APA91bHPRgkF3JUikC4ENAHEeMrd41Zxv3hVZjC9KtT8OvPVGJ-hQMRKRrZuJAEcl7B338qju59zJMjw2DELjzEvxwYv7hH5Ynpc1ODQ0aT4U4OFEeco8ohsN5PjL1iC2dNtk2BAokeMCg2ZXKqpc8FXKmhX94kIxQ#{i}"
+  end
+end

data/spec/factories/notifications.rb

@@ -0,0 +1,15 @@
+FactoryGirl.define do
+  factory :apns_notification, class: 'RubyPushNotifications::APNS::APNSNotification' do
+    tokens { [generate(:apns_token)] }
+    data a: 1
+
+    initialize_with { new tokens, data }
+  end
+
+  factory :gcm_notification, class: 'RubyPushNotifications::GCM::GCMNotification' do
+    registration_ids { [generate(:gcm_registration_id)] }
+    data a: 1
+
+    initialize_with { new registration_ids, data }
+  end
+end

data/spec/ruby-push-notifications/apns/apns_connection_spec.rb

@@ -0,0 +1,79 @@
+
+module RubyPushNotifications
+  module APNS
+    describe APNSConnection do
+
+      let(:cert) { File.read 'spec/support/dummy.pem' }
+      let(:tcp_socket) { instance_double(TCPSocket).as_null_object }
+      let(:ssl_socket) { instance_double(OpenSSL::SSL::SSLSocket).as_null_object }
+
+      describe '::open' do
+        before do
+          allow(TCPSocket).to receive(:new).with('gateway.sandbox.push.apple.com', 2195).and_return tcp_socket
+          allow(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, an_instance_of(OpenSSL::SSL::SSLContext)).and_return ssl_socket
+        end
+
+        it 'creates the connection' do
+          expect(TCPSocket).to receive(:new).with('gateway.sandbox.push.apple.com', 2195).and_return tcp_socket
+          expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, an_instance_of(OpenSSL::SSL::SSLContext)).and_return ssl_socket
+          APNSConnection.open cert, true
+        end
+
+        it 'returns an instance of APNSConnection' do
+          expect(APNSConnection.open cert, true).to be_a APNSConnection
+        end
+      end
+
+      describe '#close' do
+        let(:connection) { APNSConnection.new tcp_socket, ssl_socket }
+
+        it 'closes the ssl socket' do
+          expect(ssl_socket).to receive(:close)
+          connection.close
+        end
+
+        it 'closes the tcp socket' do
+          expect(tcp_socket).to receive(:close)
+          connection.close
+        end
+      end
+
+      describe '#write' do
+        let(:connection) { APNSConnection.new tcp_socket, ssl_socket }
+        let(:contents_string) { 'the contents string' }
+
+        it 'writes the ssl socket' do
+          expect(ssl_socket).to receive(:write).with contents_string
+          connection.write contents_string
+        end
+      end
+
+      describe '#read' do
+        let(:connection) { APNSConnection.new tcp_socket, ssl_socket }
+
+        it 'writes the ssl socket' do
+          expect(ssl_socket).to receive(:read).with 6
+          connection.read 6
+        end
+      end
+
+      describe '#flush' do
+        let(:connection) { APNSConnection.new tcp_socket, ssl_socket }
+
+        it 'flushes the ssl socket' do
+          expect(ssl_socket).to receive :flush
+          connection.flush
+        end
+      end
+
+      describe 'IO behavior' do
+        let(:connection) { APNSConnection.new tcp_socket, ssl_socket }
+
+        it 'can be selected' do
+          allow(ssl_socket).to receive(:to_io).and_return IO.new(IO.sysopen('/dev/null'))
+          IO.select [connection]
+        end
+      end
+    end
+  end
+end

data/spec/ruby-push-notifications/apns/apns_notification_spec.rb

@@ -0,0 +1,30 @@
+
+module RubyPushNotifications
+  module APNS
+    describe APNSNotification do
+      describe 'building messages for each token' do
+
+        let(:device_tokens) { ['12', '34'] }
+        let(:data) { { a: 1 } }
+        let(:notification) { APNSNotification.new device_tokens, data }
+        let(:notif_id) { 1 }
+
+        it 'successfully creates the apns binary' do
+          json = JSON.dump data
+          expect do |b|
+            notification.each_message notif_id, &b
+          end.to yield_successive_args apns_binary(json, device_tokens[0], notif_id), apns_binary(json, device_tokens[1], notif_id+1)
+        end
+
+        it 'caches the payload' do
+          expect(JSON).to receive(:dump).with(data).once.and_return 'dummy string'
+          notification.each_message(notif_id) { }
+        end
+
+        it 'validates the data'
+
+        it 'validates the tokens'
+      end
+    end
+  end
+end

data/spec/ruby-push-notifications/apns/apns_pusher_spec.rb

@@ -0,0 +1,299 @@
+
+module RubyPushNotifications
+  module APNS
+    describe APNSPusher do
+
+      let(:sandbox) { true }
+      let(:certificate) { 'abc' }
+      let(:pusher) { APNSPusher.new certificate, sandbox }
+      let(:connection) { instance_double(APNSConnection).as_null_object }
+      let(:data) { { a: 1 } }
+
+      before do
+        allow(APNSConnection).to receive(:open).with(certificate, sandbox).and_return connection
+      end
+
+      describe '#push' do
+
+        context 'a single notification' do
+
+          context 'containing a single destination' do
+
+            let(:token) { generate :apns_token }
+            let(:notification) { build :apns_notification, data: data, tokens: [token] }
+
+            describe 'success' do
+
+              before { allow(IO).to receive(:select).and_return [] }
+
+              it 'writes the notification to the socket' do
+                expect(connection).to receive(:write).with apns_binary(data, token, 0)
+                pusher.push [notification]
+              end
+
+              it 'flushes the socket contents' do
+                expect(connection).to receive(:flush)
+                pusher.push [notification]
+              end
+
+              it 'saves the results into the notification' do
+                expect do
+                  pusher.push [notification]
+                end.to change { notification.results }.from(nil).to [NO_ERROR_STATUS_CODE]
+              end
+            end
+
+            describe 'failure' do
+
+              before do
+                allow(IO).to receive(:select).and_return [[connection]]
+                allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 0].pack 'ccN'
+              end
+
+              it 'does not retry' do
+                expect(connection).to receive(:write).with(apns_binary(data, token, 0)).once
+                pusher.push [notification]
+              end
+
+              it 'saves the error' do
+                expect do
+                  pusher.push [notification]
+                end.to change { notification.results }.from(nil).to [PROCESSING_ERROR_STATUS_CODE]
+              end
+            end
+          end
+
+          context 'containing several destinations' do
+            let(:tokens) { [generate(:apns_token), generate(:apns_token)] }
+            let(:notification) { build :apns_notification, data: data, tokens: tokens }
+
+            describe 'success' do
+
+              before { allow(IO).to receive(:select).and_return [] }
+
+              it 'writes the messages to the socket' do
+                expect(connection).to receive(:write).with apns_binary(data, tokens[0], 0)
+                expect(connection).to receive(:write).with apns_binary(data, tokens[1], 1)
+                pusher.push [notification]
+              end
+
+              it 'flushes the socket contents' do
+                expect(connection).to receive(:flush).once
+                pusher.push [notification]
+              end
+
+              it 'saves the results into the notification' do
+                expect do
+                  pusher.push [notification]
+                end.to change { notification.results }.from(nil).to [NO_ERROR_STATUS_CODE, NO_ERROR_STATUS_CODE]
+              end
+            end
+
+            describe 'failure' do
+
+              let(:connection2) { instance_double(APNSConnection).as_null_object }
+
+              before do
+                allow(APNSConnection).to receive(:open).with(certificate, sandbox).and_return connection, connection2
+              end
+
+              context 'failing first' do
+                before do
+                  allow(IO).to receive(:select).and_return [[connection]], []
+                  allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 0].pack 'ccN'
+                end
+
+                it 'sends the each notification once and to the expected connection instance' do
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[0], 0)).once
+                  expect(connection2).to receive(:write).with(apns_binary(data, tokens[1], 1)).once
+                  pusher.push [notification]
+                end
+
+                it 'stores the error' do
+                  expect do
+                    pusher.push [notification]
+                  end.to change { notification.results }.from(nil).to [PROCESSING_ERROR_STATUS_CODE, NO_ERROR_STATUS_CODE]
+                end
+              end
+
+              context 'failing first but delayed error' do
+                before do
+                  allow(IO).to receive(:select).and_return [], [[connection]], []
+                  allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 0].pack 'ccN'
+                end
+
+                it 'sends the second notification twice' do
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[0], 0)).once
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[1], 1)).once
+                  expect(connection2).to receive(:write).with(apns_binary(data, tokens[1], 1)).once
+                  pusher.push [notification]
+                end
+
+                it 'stores the error' do
+                  expect do
+                    pusher.push [notification]
+                  end.to change { notification.results }.from(nil).to [PROCESSING_ERROR_STATUS_CODE, NO_ERROR_STATUS_CODE]
+                end
+              end
+
+              context 'failing last' do
+                before do
+                  allow(IO).to receive(:select).and_return [], [[connection]]
+                  allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 1].pack 'ccN'
+                end
+
+                it 'sends the second notification just once' do
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[0], 0)).once
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[1], 1)).once
+                  expect(connection2).to_not receive(:write)
+                  pusher.push [notification]
+                end
+
+                it 'stores the error' do
+                  expect do
+                    pusher.push [notification]
+                  end.to change { notification.results }.from(nil).to [NO_ERROR_STATUS_CODE, PROCESSING_ERROR_STATUS_CODE]
+                end
+              end
+            end
+          end
+        end
+
+        context 'several notifications' do
+          let(:tokens) { (0...10).map { generate:apns_token } }
+          let(:notifications) { tokens.map { |token| build :apns_notification, data: data, tokens: [token] } }
+
+          describe 'success' do
+
+            before { allow(IO).to receive(:select).and_return [] }
+
+            it 'writes the notifications to the socket' do
+              notifications.each_with_index do |notification, i|
+                expect(connection).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+              end
+              pusher.push notifications
+            end
+
+            it 'flushes the socket contents' do
+              expect(connection).to receive(:flush).once
+              pusher.push notifications
+            end
+
+            it 'saves results' do
+              expect do
+                pusher.push notifications
+              end.to change { notifications.map { |n| n.results } }.from([nil]*10).to([[NO_ERROR_STATUS_CODE]]*10)
+            end
+          end
+
+          describe 'failure' do
+
+            context 'several async failures' do
+
+              let(:connection2) { instance_double(APNSConnection).as_null_object }
+              let(:connection3) { instance_double(APNSConnection).as_null_object }
+              let(:connection4) { instance_double(APNSConnection).as_null_object }
+
+              before do
+                allow(IO).to receive(:select).and_return [], [], [[connection]], [], [], [[connection2]], [], [], [], [], [], [], [[connection3]]
+                allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 0].pack('ccN')
+                allow(connection2).to receive(:read).with(6).and_return [8, MISSING_DEVICE_TOKEN_STATUS_CODE, 2].pack('ccN')
+                allow(connection3).to receive(:read).with(6).and_return [8, INVALID_TOPIC_SIZE_STATUS_CODE, 9].pack('ccN')
+                allow(APNSConnection).to receive(:open).with(certificate, sandbox).and_return connection, connection2, connection3, connection4
+              end
+
+              it 'repones the connection' do
+                (0..2).each do |i|
+                  expect(connection).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+                end
+                expect(connection).to_not receive(:write).with apns_binary(data, tokens[3], 3)
+
+                expect(connection2).to_not receive(:write).with apns_binary(data, tokens[0], 0)
+                (1..3).each do |i|
+                  expect(connection2).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+                end
+                expect(connection2).to_not receive(:write).with apns_binary(data, tokens[4], 4)
+
+                expect(connection3).to_not receive(:write).with apns_binary(data, tokens[2], 2)
+                (3..9).each do |i|
+                  expect(connection3).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+                end
+
+                expect(connection4).to_not receive :write
+                pusher.push notifications
+              end
+
+              it 'saves the statuses' do
+                expect do
+                  pusher.push notifications
+                end.to change { notifications.map { |n| n.results } }.from([nil]*10).to [
+                    [PROCESSING_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [MISSING_DEVICE_TOKEN_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [INVALID_TOPIC_SIZE_STATUS_CODE]
+                  ]
+              end
+            end
+
+            context 'several sync failures' do
+
+              let(:connection2) { instance_double(APNSConnection).as_null_object }
+              let(:connection3) { instance_double(APNSConnection).as_null_object }
+              let(:connection4) { instance_double(APNSConnection).as_null_object }
+
+              before do
+                allow(IO).to receive(:select).and_return [[connection]], [], [[connection2]], [], [], [], [], [], [], [[connection3]]
+                allow(connection).to receive(:read).with(6).and_return [8, PROCESSING_ERROR_STATUS_CODE, 0].pack('ccN')
+                allow(connection2).to receive(:read).with(6).and_return [8, MISSING_DEVICE_TOKEN_STATUS_CODE, 2].pack('ccN')
+                allow(connection3).to receive(:read).with(6).and_return [8, INVALID_TOPIC_SIZE_STATUS_CODE, 9].pack('ccN')
+                allow(APNSConnection).to receive(:open).with(certificate, sandbox).and_return connection, connection2, connection3, connection4
+              end
+
+              it 'repones the connection' do
+                expect(connection).to receive(:write).with(apns_binary(data, tokens[0], 0)).once
+                expect(connection).to_not receive(:write).with apns_binary(data, tokens[1], 1)
+
+                expect(connection2).to_not receive(:write).with apns_binary(data, tokens[0], 0)
+                (1..2).each do |i|
+                  expect(connection2).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+                end
+                expect(connection2).to_not receive(:write).with apns_binary(data, tokens[3], 3)
+
+                expect(connection3).to_not receive(:write).with apns_binary(data, tokens[2], 2)
+                (3..9).each do |i|
+                  expect(connection3).to receive(:write).with(apns_binary(data, tokens[i], i)).once
+                end
+
+                expect(connection4).to_not receive :write
+                pusher.push notifications
+              end
+
+              it 'saves the statuses' do
+                expect do
+                  pusher.push notifications
+                end.to change { notifications.map { |n| n.results } }.from([nil]*10).to [
+                    [PROCESSING_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [MISSING_DEVICE_TOKEN_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [NO_ERROR_STATUS_CODE],
+                    [INVALID_TOPIC_SIZE_STATUS_CODE]
+                  ]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end