crusade_rails 0.0.1

data/test/javascripts/support/safari.coffee

@@ -0,0 +1,7 @@
+@mockSafariPushNotification = ->
+  window.safari =
+    pushNotification:
+      fakeResult:
+        permission: 'default'
+      permission: (permissionData) -> console.log 'permission'
+      requestPermission: (url, pushId, userData, callback) -> callback(window.safari.pushNotification.fakeResult)

data/test/javascripts/test_helper.coffee

@@ -0,0 +1,25 @@
+# Teaspoon includes some support files, but you can use anything from your own support path too.
+# require support/jasmine-jquery
+# require support/sinon
+# require support/your-support-file
+#
+# Deferring execution
+# If you're using CommonJS, RequireJS or some other asynchronous library you can defer execution. Call Teaspoon.execute()
+# after everything has been loaded. Simple example of a timeout:
+#
+# Teaspoon.defer = true
+# setTimeout(Teaspoon.execute, 1000)
+#
+# Matching files
+# By default Teaspoon will look for files that match _spec.{js,js.coffee,.coffee}. Add a filename_spec.js file in your
+# spec path and it'll be included in the default suite automatically. If you want to customize suites, check out the
+# configuration in config/initializers/teaspoon.rb
+#
+# Manifest
+# If you'd rather require your spec files manually (to control order for instance) you can disable the suite matcher in
+# the configuration and use this file as a manifest.
+#
+# For more information: http://github.com/modeset/teaspoon
+#
+# You can require javascript files here. A good place to start is by requiring your application.js.
+#= require application

data/test/javascripts/unit/configuration_test.js.coffee

@@ -0,0 +1,11 @@
+
+describe 'configuration', ->
+
+  it 'attaches the configuration on the window', ->
+    expect(window.crusade).toBeDefined()
+
+  it 'sets the push_id', ->
+    expect(window.crusade.pushId).toEqual 'web.com.example.push.id'
+
+  it 'sets the webservice url', ->
+    expect(window.crusade.webserviceUrl).toEqual 'https://www.example.com/push'

data/test/javascripts/unit/crusade_test.js.coffee

@@ -0,0 +1,102 @@
+
+describe 'Crusade', ->
+  subject = null
+
+  beforeEach ->
+    subject = new Crusade()
+
+  describe 'request push notification permission', ->
+    callback = null
+    permissionResult = null
+
+    beforeEach ->
+      mockSafariPushNotification()
+
+      callback = (permission) -> permissionResult = permission
+
+    describe 'the user was already requested', ->
+      afterEach ->
+        expect(window.safari.pushNotification.permission).toHaveBeenCalledWith 'web.com.example.push.id'
+
+
+      describe 'the user granted the permission', ->
+        it 'executes the success function if the user has already granted the permission', ->
+          spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'granted', deviceToken: 'deviceToken'})
+
+          subject.requestPermission('userId').granted(callback)
+
+          expect(permissionResult.permission).toEqual 'granted'
+
+        it 'wraps the safari permission into a crusade permission', ->
+          spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'granted', deviceToken: 'deviceToken'})
+
+          subject.requestPermission('userId').granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(NotificationPermission)
+
+      describe 'the user denied the permission', ->
+        it 'executes the error function if the user has already denied the permission', ->
+          spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'denied'})
+
+          subject.requestPermission('userId').denied(callback)
+
+          expect(permissionResult.permission).toEqual 'denied'
+
+    describe 'the user has never been requested', ->
+      permissionCallback = null
+
+      beforeEach ->
+        spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'default'})
+
+        permissionCallback = (permission) -> callback(permission)
+
+      afterEach ->
+        expect(window.safari.pushNotification.requestPermission).toHaveBeenCalledWith 'https://www.example.com/push',
+          'web.com.example.push.id'
+          {userId: 'userId'}
+          jasmine.any(Function)
+
+      describe 'the user denies the permission', ->
+        it 'executes the success function if the user has already granted the permission', ->
+          window.safari.pushNotification.fakeResult = { permission: 'granted', deviceToken: 'deviceToken' }
+          spyOn(window.safari.pushNotification, 'requestPermission').andCallThrough()
+
+          subject.requestPermission('userId').granted(callback)
+
+          expect(permissionResult.permission).toEqual 'granted'
+
+        it 'wraps the safari permission into a crusade permission', ->
+          window.safari.pushNotification.fakeResult = { permission: 'granted', deviceToken: 'deviceToken' }
+          spyOn(window.safari.pushNotification, 'requestPermission').andCallThrough()
+
+          subject.requestPermission('userId').granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(NotificationPermission)
+
+      describe 'the user grants the permission', ->
+        it 'executes the error function if the user has already denied the permission', ->
+          window.safari.pushNotification.fakeResult = { permission: 'denied' }
+          spyOn(window.safari.pushNotification, 'requestPermission').andCallThrough()
+
+          subject.requestPermission('userId').denied(callback)
+
+          expect(permissionResult.permission).toEqual 'denied'
+
+    describe 'checkPermission', ->
+      afterEach ->
+        expect(window.safari.pushNotification.permission).toHaveBeenCalledWith 'web.com.example.push.id'
+
+
+      it 'returns the result of the current permission', ->
+        spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'granted', deviceToken: 'deviceToken'})
+
+        permissionResult = subject.checkPermission()
+
+        expect(permissionResult.permission).toEqual 'granted'
+
+      it 'wraps the safari permission into a crusade permission', ->
+        spyOn(window.safari.pushNotification, 'permission').andReturn({permission: 'granted', deviceToken: 'deviceToken'})
+
+        permissionResult = subject.checkPermission()
+
+        expect(permissionResult).toEqual jasmine.any(NotificationPermission)

data/test/javascripts/unit/notification_permission_test.js.coffee

@@ -0,0 +1,49 @@
+
+describe 'NotificationPermission', ->
+  subject = null
+
+  describe 'constructor', ->
+    safariPermission = {}
+
+    it 'copies the permission', ->
+      safariPermission = { permission: "granted" }
+
+      subject = new NotificationPermission(safariPermission)
+
+      expect(subject.permission).toEqual "granted"
+
+    it 'copies the deviceToken', ->
+      safariPermission = { deviceToken: "1234q" }
+
+      subject = new NotificationPermission(safariPermission)
+
+      expect(subject.deviceToken).toEqual "1234q"
+
+    describe 'no safariPermission', ->
+      beforeEach ->
+        subject = new NotificationPermission()
+
+      it 'has a default permission', ->
+        expect(subject.permission).toEqual "default"
+
+      it 'does not have deviceToken', ->
+        expect(subject.deviceToken).toBeNull()
+
+  describe 'isGranted', ->
+    beforeEach ->
+      subject = new NotificationPermission()
+
+    it 'is granted if the permission is "granted"', ->
+      subject.permission = 'granted'
+
+      expect(subject.isGranted()).toBe(true)
+
+    it 'is not granted if the permission is "default"', ->
+      subject.permission = 'default'
+
+      expect(subject.isGranted()).toBe(false)
+
+    it 'is not granted if the permission is "denied"', ->
+      subject.permission = 'denied'
+
+      expect(subject.isGranted()).toBe(false)

data/test/routes/apns_routes_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+describe 'APNS routes Integration Test' do
+  it 'routes the push package creation' do
+    assert_regonize_route 'post', '/apns/v1/pushPackages/web.com.example.push.id',
+                          controller: 'crusade_rails/apns/v1/push_package',
+                          action: 'create'
+  end
+
+  it 'routes the push notification subscription' do
+    assert_regonize_route 'post', '/apns/v1/devices/1234a/registrations/web.com.example.push.id',
+                          controller: 'crusade_rails/apns/v1/subscription',
+                          action: 'create'
+  end
+
+  it 'routes the push notification unsubscription' do
+    assert_regonize_route 'delete', '/apns/v1/devices/1234a/registrations/web.com.example.push.id',
+                          controller: 'crusade_rails/apns/v1/subscription',
+                          action: 'delete'
+  end
+
+  it 'routes the logs' do
+    assert_regonize_route 'post', '/apns/v1/log',
+                          controller: 'crusade_rails/apns/v1/log', action: 'create'
+  end
+
+
+  def engine_routes
+    CrusadeRails::Engine.routes
+  end
+
+  def assert_regonize_route(method, path, controller)
+    recognize = engine_routes.recognize_path path, method: method
+    recognize.wont_be_nil "#{method} #{path} is not recognized"
+
+    controller[:controller].must_equal recognize[:controller]
+    controller[:action].must_equal recognize[:action]
+  end
+end

data/test/services/notification_service_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+describe CrusadeRails::NotificationService do
+  let(:fake_push_notification) { FakePushNotification.new }
+
+  subject { CrusadeRails::NotificationService.new fake_push_notification }
+
+  describe 'default constructor' do
+    it 'sets a crusade apns push notification' do
+      service = CrusadeRails::NotificationService.new
+
+      service.push_notification.is_a?(Crusade::APNS::PushNotification).must_be_true
+    end
+
+    it 'sets correctly the configuration' do
+      service = CrusadeRails::NotificationService.new
+
+      service.push_notification.configuration.must_be_same_as Rails.application.config.crusade
+    end
+  end
+
+  describe 'send_notification' do
+    let(:attr) { { title: 'the title', body: 'the body' } }
+    let(:user_id) { 1234 }
+
+    let(:subscription) { CrusadeRails::UserSubscription.new(user_id: 1234, device_token: 'aaaa', active: true) }
+
+    before do
+      CrusadeRails::UserSubscription.stubs(:where).returns([])
+      CrusadeRails::UserSubscription.stubs(:where).with(user_id: user_id).returns([subscription])
+    end
+
+    describe 'notification active' do
+      before { subject.send_notification user_id, attr }
+      let(:last_sent) { fake_push_notification.last_notification }
+
+      it 'sends a push notification' do
+        fake_push_notification.sent?.must_be_true
+      end
+
+      it 'converts the push notification' do
+        last_sent.title.must_equal 'the title'
+        last_sent.body.must_equal  'the body'
+      end
+
+      it 'sents to the correct device' do
+        last_sent.device_token.must_equal  'aaaa'
+      end
+    end
+
+    describe 'no notification for the user' do
+      it 'does not send any notification' do
+        subject.send_notification 'unknown', attr
+
+        fake_push_notification.sent?.must_be_false
+      end
+    end
+
+    describe 'notification inactive' do
+      before { subscription.active = false }
+
+      it 'does not send any notification' do
+        subject.send_notification user_id, attr
+
+        fake_push_notification.sent?.must_be_false
+      end
+    end
+  end
+end

data/test/services/user_subscription_service_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+describe CrusadeRails::UserSubscriptionService do
+  before { CrusadeRails::UserSubscription.delete_all }
+  after  { CrusadeRails::UserSubscription.delete_all }
+
+  let(:user_id)    { 123 }
+
+  describe 'register' do
+    subject { CrusadeRails::UserSubscriptionService.new }
+
+    let(:registration) { subject.register user_id, user_token }
+    let(:user_token)   { '1234a' }
+    let(:subscription) { CrusadeRails::UserSubscription.where(user_id: user_id).first }
+
+    before { registration }
+
+    it 'registers the user id' do
+      subscription.user_id.must_equal user_id
+    end
+
+    it 'registers the user token' do
+      subscription.user_token.must_equal user_token
+    end
+
+    it 'creates a subscription entry' do
+      subscription.wont_be_nil
+    end
+
+    it 'does no contains a device token' do
+      subscription.device_token.must_be_nil
+    end
+
+    it 'is not activated' do
+      subscription.active?.must_be_false
+    end
+
+    it 'returns true when the registration is successfull' do
+      registration.must_be_true
+    end
+  end
+
+  describe 'subscribe' do
+    let(:user_token) { '1234' }
+    let(:device_token) { 'abcd' }
+
+    subject { CrusadeRails::UserSubscriptionService.new}
+
+    describe 'no previous subscription' do
+      before do
+        CrusadeRails::UserSubscription.new(user_id: user_id, user_token: user_token).save!
+
+        subject.subscribe user_token, device_token
+      end
+
+      let(:subscription) { CrusadeRails::UserSubscription.where(user_id: user_id).first }
+
+      it 'sets the device token' do
+        subscription.device_token.must_equal device_token
+      end
+
+      it 'activates the subscription' do
+        subscription.active?.must_be_true
+      end
+
+      it { subject.subscribe(user_token, device_token).must_be_true }
+    end
+
+    describe 'previous subscription' do
+    end
+
+    describe 'subscription not found' do
+    end
+  end
+
+  describe 'unsubscribe' do
+    let(:user_token) { '1234' }
+    let(:device_token) { 'abcd' }
+
+    subject { CrusadeRails::UserSubscriptionService.new}
+
+    describe 'no previous subscription' do
+      before do
+        CrusadeRails::UserSubscription.new(user_id: user_id, user_token: user_token, active: true).save!
+
+        subject.unsubscribe user_token, device_token
+      end
+
+      let(:subscription) { CrusadeRails::UserSubscription.where(user_id: user_id).first }
+
+      it 'unactivate the subscription' do
+        subscription.active?.must_be_false
+      end
+
+      it { subject.unsubscribe(user_token, device_token).must_be_true }
+    end
+
+    describe 'previous subscription' do
+    end
+
+    describe 'subscription not found' do
+    end
+  end
+end

data/test/support/fake_push_notification.rb

@@ -0,0 +1,24 @@
+
+class FakePushNotification
+  attr_reader :sent, :configuration
+
+  def initialize
+    reset
+  end
+
+  def send notification
+    @sent << notification
+  end
+
+  def reset
+    @sent = []
+  end
+
+  def sent?
+    @sent.size > 0
+  end
+
+  def last_notification
+    @sent.last
+  end
+end

data/test/teaspoon_env.rb

@@ -0,0 +1,33 @@
+# This file allows you to override various Teaspoon configuration directives when running from the command line. It is not
+# required from within the Rails environment, so overriding directives that have been defined within the initializer
+# is not possible.
+#
+# Set RAILS_ROOT and load the environment.
+ENV["RAILS_ROOT"] = File.expand_path("../../", __FILE__)
+require File.expand_path("../../test/dummy/config/environment", __FILE__)
+
+# Provide default configuration.
+#
+# You can override various configuration directives defined here by using arguments with the teaspoon command.
+#
+# teaspoon --driver=selenium --suppress-log
+# rake teaspoon DRIVER=selenium SUPPRESS_LOG=false
+Teaspoon.setup do |config|
+  # Driver / Server
+  #config.driver           = "phantomjs" # available: phantomjs, selenium
+  #config.server           = nil # defaults to Rack::Server
+
+  # Behaviors
+  #config.server_timeout   = 20 # timeout for starting the server
+  #config.server_port      = nil # defaults to any open port unless specified
+  #config.fail_fast        = true # abort after the first failing suite
+
+  # Output
+  #config.formatters       = "dot" # available: dot, tap, tap_y, swayze_or_oprah
+  #config.suppress_log     = false # suppress logs coming from console[log/error/debug]
+  #config.color            = true
+
+  # Coverage (requires istanbul -- https://github.com/gotwarlost/istanbul)
+  #config.coverage         = true
+  #config.coverage_reports = "text,html,cobertura"
+end

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+
+require "rails/test_help"
+require "minitest/spec"
+require "minitest/rails"
+require "minitest/mock"
+require "minitest/great_expectations"
+
+require "mocha"
+
+module ActiveRecord::TestFixtures
+  def before_setup
+    super
+  end
+
+  def after_teardown
+    super
+  end
+end
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }