fcm-ruby-push-notifications 1.2.0

data/spec/factories.rb

@@ -0,0 +1,17 @@
+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
+
+  sequence :mpns_device_url do |i|
+    "http://s.notify.live.net/u/1/bn1/HmQAAACP-0esPuxBSkzBNNXH4W0lV3lK-stEw6eRfpXX39uYbM7IwehXOTO9pRBjaaGECWOdD_7x5j5U4w4iXG4hGxer/d2luZG93c3Bob25lZGVmYXVsdA/EMDhx32Q5BG0DWnZpuVX1g/kRFAu0-jnhMQ-HG94rXzrbb0wQk#{i}"
+  end
+
+  sequence :wns_device_url do |i|
+    "https://hk2.notify.windows.com/?token=AwYAAABe%2bpjShu%2fzcVaaf1NPm%2b2dpiosm7RnmBJGMVkBDiYNXpAEp0mETldEu8axFoamgwb%2fdKCuNSfGGDHZ3RcaO2fcNGfxC6Y4Yp3xTFkDOhv5kNfgSXef7pSP0uwueIpqbWI%3d#{i}"
+  end
+end

data/spec/factories/notifications.rb

@@ -0,0 +1,30 @@
+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
+
+  factory :mpns_notification, class: 'RubyPushNotifications::MPNS::MPNSNotification' do
+    device_urls { [generate(:mpns_device_url)] }
+    data message: { value1: 'hello' }
+
+    initialize_with { new device_urls, data }
+  end
+
+  factory :wns_notification, class: 'RubyPushNotifications::WNS::WNSNotification' do
+    device_urls { [generate(:wns_device_url)] }
+    data message: { value1: 'hello' }
+
+    initialize_with { new device_urls, data }
+  end
+
+end

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

@@ -0,0 +1,92 @@
+
+module RubyPushNotifications
+  module APNS
+    describe APNSConnection do
+
+      let(:cert) { File.read 'spec/support/dummy.pem' }
+      let(:tcp_socket) { instance_double(Socket).as_null_object }
+      let(:ssl_socket) { instance_double(OpenSSL::SSL::SSLSocket).as_null_object }
+
+      describe '::open' do
+        before do
+          allow(Socket).to receive(:tcp).with('gateway.sandbox.push.apple.com', 2195, nil, nil, { connect_timeout: 30 }).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(Socket).to receive(:tcp).with('gateway.sandbox.push.apple.com', 2195, nil, nil, { connect_timeout: 30 }).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
+
+        it 'sets the password for pem file' do
+          expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, an_instance_of(OpenSSL::SSL::SSLContext)).and_return ssl_socket
+          expect(OpenSSL::PKey::RSA).to receive(:new).with(cert, 'password')
+          expect(APNSConnection.open(cert, true, 'password')).to be_a APNSConnection
+        end
+
+        context 'when :host option is present' do
+          it 'opens a connection with a custom APNS' do
+            expect(Socket).to receive(:tcp).with('gateway.push.example.com', 2195, nil, nil, { connect_timeout: 30 }).and_return tcp_socket
+            APNSConnection.open cert, true, 'password', { host: "gateway.push.example.com" }
+          end
+        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,42 @@
+
+module RubyPushNotifications
+  module APNS
+    describe APNSNotification 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'
+        allow(data).to receive(:respond_to?).with(:to_json).and_return(false)
+        notification.each_message(notif_id) {}
+      end
+
+      it 'validates the data'
+
+      it 'validates the tokens'
+
+      it_behaves_like 'a proper results manager' do
+        let(:success_count) { 2 }
+        let(:failures_count) { 1 }
+        let(:individual_results) do
+          [
+            NO_ERROR_STATUS_CODE,
+            PROCESSING_ERROR_STATUS_CODE,
+            NO_ERROR_STATUS_CODE
+          ]
+        end
+        let(:results) { APNSResults.new individual_results }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,295 @@
+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, nil, {}).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
+
+              describe 'results' do
+                before { pusher.push [notification] }
+
+                include_examples 'right results', 1, 0, [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
+
+              describe 'results' do
+                before { pusher.push [notification] }
+
+                include_examples 'right results', 0, 1, [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
+
+              describe 'results' do
+                before { pusher.push [notification] }
+
+                include_examples 'right results', 2, 0, [NO_ERROR_STATUS_CODE] * 2
+              end
+            end
+
+            describe 'failure' do
+
+              let(:connection2) { instance_double(APNSConnection).as_null_object }
+
+              before do
+                allow(APNSConnection).to receive(:open).with(certificate, sandbox, nil, {}).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
+
+                describe 'results' do
+                  before { pusher.push [notification] }
+
+                  include_examples 'right results', 1, 1, [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
+
+                describe 'results' do
+                  before { pusher.push [notification] }
+
+                  include_examples 'right results', 1, 1, [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
+
+                describe 'results' do
+                  before { pusher.push [notification] }
+
+                  include_examples 'right results', 1, 1, [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
+              pusher.push notifications
+              expect(notifications.map(&:individual_results)).to eq [[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, nil, {}).and_return connection, connection2, connection3, connection4
+              end
+
+              it 'reopens 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
+                pusher.push notifications
+                expect(notifications.map(&:individual_results)).to eq [
+                    [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, nil, {}).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
+                pusher.push notifications
+                expect(notifications.map(&:individual_results)).to eq [
+                    [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