crusade_rails 0.8.0 → 0.8.2

data/test/javascripts/support/safari.js.coffee

@@ -4,4 +4,9 @@
       fakeResult:
         permission: 'default'
       permission: (permissionData) -> console.log 'permission'
-      requestPermission: (url, pushId, userData, callback) -> callback(window.safari.pushNotification.fakeResult)
+      requestPermission: (url, pushId, userData, callback) -> callback(window.safari.pushNotification.fakeResult)
+
+@mockLocalNotification = ->
+  window.Notification =
+    permission: 'default'
+    requestPermission: (callback) -> callback(window.Notification.fakeResult)

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

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

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

@@ -0,0 +1,130 @@
+describe 'Crusade.LocalNotification', ->
+  subject = null
+
+  beforeEach ->
+    subject = new Crusade.LocalNotification()
+
+  describe 'request local notification permission', ->
+    callback = null
+    permissionResult = null
+
+    beforeEach ->
+      mockLocalNotification()
+
+      callback = (permission) -> permissionResult = permission
+
+    describe 'the user was already requested', ->
+      describe 'the user granted the permission', ->
+        it 'executes the success function if the user has already granted the permission', ->
+          window.Notification.permission = 'granted'
+
+          subject.requestPermission().granted(callback)
+
+          expect(permissionResult.permission).toEqual 'granted'
+
+        it 'wraps the safari permission into a crusade permission', ->
+          window.Notification.permission = 'granted'
+
+          subject.requestPermission().granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(Crusade.NotificationPermission)
+
+      it 'executes the error function if the user has already denied the permission', ->
+        window.Notification.permission = 'denied'
+
+        subject.requestPermission().denied(callback)
+
+        expect(permissionResult.permission).toEqual 'denied'
+
+    describe 'the user has never been requested', ->
+      permissionCallback = null
+
+      beforeEach ->
+        permissionCallback = (permission) -> callback(permission)
+        mockLocalNotification()
+
+      describe 'the user grants the permission', ->
+        it 'executes the grants function if the user', ->
+          window.Notification.fakeResult = 'granted'
+
+          subject.requestPermission().granted(callback)
+
+          expect(permissionResult.permission).toEqual 'granted'
+
+        it 'wraps the safari permission into a crusade permission', ->
+          window.Notification.fakeResult = 'granted' 
+
+          subject.requestPermission().granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(Crusade.NotificationPermission)
+
+      describe 'the user denies the permission', ->
+        it 'executes the error function', ->
+          window.Notification.fakeResult = 'denied'
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'denied'
+
+      describe 'the browser does not support local notifications', ->
+        it 'returns unsupported', ->
+          window.Notification = undefined
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'unsupported'
+
+    describe 'checkPermission', ->
+      beforeEach ->
+        window.Notification.permission = 'granted'
+
+      describe 'the browser is supported', ->
+
+        it 'returns the result of the current permission', ->
+          permissionResult = subject.checkPermission()
+
+          expect(permissionResult.permission).toEqual 'granted'
+
+        it 'wraps the safari permission into a crusade permission', ->
+          permissionResult = subject.checkPermission()
+
+          expect(permissionResult).toEqual jasmine.any(Crusade.NotificationPermission)
+
+      describe 'the browser does not support local notifications', ->
+        it 'returns unsupported', ->
+          window.Notification = undefined
+
+          permissionResult = subject.checkPermission()
+
+          expect(permissionResult.permission).toEqual 'unsupported'
+
+    describe 'send notification', ->
+      notification = null
+
+      beforeEach ->
+        window.Notification = FakeNotification
+
+      describe 'the user granted the permission', ->
+        beforeEach ->
+          window.Notification.permission = 'granted'
+
+          notification = subject.notify('title', 'the body')
+
+        it 'creates a new notification', ->
+          expect(notification).toBeDefined()
+
+        it 'sets the title of the notification', ->
+          expect(notification.title).toEqual 'title'
+
+        it 'sets the body of the notification', ->
+          expect(notification.body).toEqual 'the body'
+
+      describe 'the user denied the permission', ->
+        beforeEach ->
+          window.Notification.permission = 'denied'
+
+          notification = subject.notify('title', 'the body')
+
+        it 'returns "unauthorized"', ->
+          expect(notification).toEqual 'unauthorized'
+

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

@@ -1,5 +1,5 @@
 
-describe 'NotificationPermission', ->
+describe 'Crusade.NotificationPermission', ->
   subject = null
 
   describe 'constructor', ->
@@ -8,20 +8,20 @@ describe 'NotificationPermission', ->
     it 'copies the permission', ->
       safariPermission = { permission: "granted" }
 
-      subject = new NotificationPermission(safariPermission)
+      subject = new Crusade.NotificationPermission(safariPermission)
 
       expect(subject.permission).toEqual "granted"
 
     it 'copies the deviceToken', ->
       safariPermission = { deviceToken: "1234q" }
 
-      subject = new NotificationPermission(safariPermission)
+      subject = new Crusade.NotificationPermission(safariPermission)
 
       expect(subject.deviceToken).toEqual "1234q"
 
     describe 'no safariPermission', ->
       beforeEach ->
-        subject = new NotificationPermission()
+        subject = new Crusade.NotificationPermission()
 
       it 'has a default permission', ->
         expect(subject.permission).toEqual "default"
@@ -31,7 +31,7 @@ describe 'NotificationPermission', ->
 
   describe 'isGranted', ->
     beforeEach ->
-      subject = new NotificationPermission()
+      subject = new Crusade.NotificationPermission()
 
     it 'is granted if the permission is "granted"', ->
       subject.permission = 'granted'

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

@@ -0,0 +1,180 @@
+describe 'Crusade.PushNotification', ->
+  subject = null
+
+  beforeEach ->
+    subject = new Crusade.PushNotification()
+
+  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().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().granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(Crusade.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().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'})
+
+        $.mockjax(
+          url: 'https://www.example.com/push/v1/pushPackages/web.com.example.push.id/new',
+          dataType: 'json'
+          responseText: {
+            "user_subscription": {
+            "user_id": 2,
+            "authenticity_token": "abcde"
+            }
+          })
+
+        permissionCallback = (permission) -> callback(permission)
+
+      afterEach ->
+        $.mockjaxClear()
+
+      expectSafariRequest = ->
+        expect(window.safari.pushNotification.requestPermission).toHaveBeenCalledWith 'https://www.example.com/push',
+          'web.com.example.push.id'
+          {user_id: '2', authenticity_token: 'abcde' }
+          jasmine.any(Function)
+
+      describe 'the user grants the permission', ->
+        it 'executes the success function', ->
+          window.safari.pushNotification.fakeResult = { permission: 'granted', deviceToken: 'deviceToken' }
+          spyOn(window.safari.pushNotification, 'requestPermission').andCallThrough()
+
+          subject.requestPermission().granted(callback)
+
+          expect(permissionResult.permission).toEqual 'granted'
+          expectSafariRequest()
+
+        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().granted(callback)
+
+          expect(permissionResult).toEqual jasmine.any(Crusade.NotificationPermission)
+
+      describe 'the user denies the permission', ->
+        it 'executes the error function', ->
+          window.safari.pushNotification.fakeResult = { permission: 'denied' }
+          spyOn(window.safari.pushNotification, 'requestPermission').andCallThrough()
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'denied'
+          expectSafariRequest()
+
+
+      describe 'there is an error in the authenticity request', ->
+        it 'fails if the request fails', ->
+          $.mockjaxClear()
+          $.mockjax(
+            url: 'https://www.example.com/push/v1/pushPackages/web.com.example.push.id/new'
+            dataType: 'json'
+            status: 404
+          )
+          spyOn(window.safari.pushNotification, 'requestPermission')
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'unauthenticated'
+
+        it 'fails if the request does not contain a permission', ->
+          $.mockjaxClear()
+          $.mockjax(
+            url: 'https://www.example.com/push/v1/pushPackages/web.com.example.push.id/new'
+            dataType: 'json'
+            responseText: {}
+          )
+          spyOn(window.safari.pushNotification, 'requestPermission')
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'unauthenticated'
+
+      describe 'the brwoser is not supported', ->
+        it 'returns unsupported if the browser is no Safari', ->
+          window.safari = undefined
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'unsupported'
+
+        it 'returns unsupported if Safari does not support push notifications', ->
+          window.safari.pushNotification = undefined
+
+          subject.requestPermission().denied(callback)
+
+          expect(permissionResult.permission).toEqual 'unsupported'
+
+    describe 'checkPermission', ->
+      beforeEach ->
+        window.safari =
+          pushNotification:
+            permission: -> true
+
+      describe 'the browser is supported', ->
+        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(Crusade.NotificationPermission)
+
+      describe 'the browser is not supported', ->
+        it 'returns unsupported if the browser is no Safari', ->
+          window.safari = undefined
+
+          permissionResult = subject.checkPermission()
+
+          expect(permissionResult.permission).toEqual 'unsupported'
+
+        it 'returns unsupported if Safari does not support push notifications', ->
+          window.safari.pushNotification = undefined
+
+          permissionResult = subject.checkPermission()
+
+          expect(permissionResult.permission).toEqual 'unsupported'

data/test/routes/apns_routes_test.rb

@@ -7,6 +7,12 @@ describe 'APNS routes Integration Test' do
                           action: 'create'
   end
 
+  it 'routes the push package new authorization id' do
+    assert_regonize_route 'get', '/apns/v1/pushPackages/web.com.example.push.id/new',
+                          controller: 'crusade_rails/apns/v1/push_package',
+                          action: 'new'
+  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',

data/test/services/user_subscription_service_test.rb

@@ -4,39 +4,118 @@ describe CrusadeRails::UserSubscriptionService do
   before { CrusadeRails::UserSubscription.delete_all }
   after  { CrusadeRails::UserSubscription.delete_all }
 
+  subject { CrusadeRails::UserSubscriptionService.new user_id }
+
   let(:user_id)    { 123 }
 
-  describe 'register' do
-    subject { CrusadeRails::UserSubscriptionService.new }
+  describe 'initialize' do
+    it { subject.user_id.must_equal user_id }
 
-    let(:registration) { subject.register user_id, user_token }
-    let(:user_token)   { '1234a' }
-    let(:subscription) { CrusadeRails::UserSubscription.where(user_id: user_id).first }
+    it 'does not support user_id nil' do
+      -> { CrusadeRails::UserSubscriptionService.new nil }.must_raise TypeError
+    end
+
+    it 'does not support an non numeric user_id' do
+      -> { CrusadeRails::UserSubscriptionService.new 'aaa' }.must_raise ArgumentError
+    end
+  end
 
-    before { registration }
+  describe 'new_subscription' do
+    let(:subscription) { CrusadeRails::UserSubscription.last }
 
-    it 'registers the user id' do
+    before { subject.new_subscription }
+
+    it 'creates a new subscription' do
+      subscription.wont_be_nil
+    end
+
+    it 'sets 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
+    it 'generates a long authenticity token' do
+      subscription.authenticity_token.wont_be_nil
+      (subscription.authenticity_token.size >= 100).must_be_true
     end
 
-    it 'creates a subscription entry' do
-      subscription.wont_be_nil
+    it 'generates different token' do
+      tokens = 50.times.map do |i|
+        CrusadeRails::UserSubscriptionService.new(user_id).new_subscription.authenticity_token
+      end
+
+      tokens.uniq.must_equal tokens
     end
 
-    it 'does no contains a device token' do
-      subscription.device_token.must_be_nil
+    describe 'the user already has a subscription' do
+      it 'does not create a new subscription in database' do
+        subject.new_subscription
+
+        CrusadeRails::UserSubscription.where(user_id: user_id).count.must_equal 1
+      end
+
+      it 'replace the authenticity token' do
+        authenticity_token = subscription.authenticity_token
+
+        subject.new_subscription
+
+        CrusadeRails::UserSubscription.where(user_id: user_id).last.authenticity_token.wont_equal authenticity_token
+      end
     end
+  end
 
-    it 'is not activated' do
-      subscription.active?.must_be_false
+  describe 'register' do
+    let(:authenticity_token) { 'aaaa' }
+    let(:registration) { subject.register authenticity_token, user_token }
+    let(:user_token)   { '1234a' }
+   
+    let(:subscription) { CrusadeRails::UserSubscription.where(user_id: user_id).first }
+    let(:initial) { CrusadeRails::UserSubscription.create(user_id: user_id, authenticity_token: initial_authenticity_token) }
+    let(:initial_authenticity_token) { 'aaaa' }
+    
+    before do
+      initial
     end
 
-    it 'returns true when the registration is successfull' do
-      registration.must_be_true
+    describe 'valid authenticity token' do
+      before do
+        registration
+      end
+
+      it 'updates the initial subscription' do
+        subscription.id.must_equal initial.id
+      end
+
+      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 'wrong authenticity token' do
+      let(:initial_authenticity_token) { 'bbbbb' }
+
+      it 'returns unauthenticated' do
+        registration.must_equal :unauthenticated
+      end
     end
   end
 
@@ -44,7 +123,7 @@ describe CrusadeRails::UserSubscriptionService do
     let(:user_token) { '1234' }
     let(:device_token) { 'abcd' }
 
-    subject { CrusadeRails::UserSubscriptionService.new}
+    subject { CrusadeRails::UserSubscriptionService.new user_id }
 
     describe 'no previous subscription' do
       before do
@@ -77,7 +156,7 @@ describe CrusadeRails::UserSubscriptionService do
     let(:user_token) { '1234' }
     let(:device_token) { 'abcd' }
 
-    subject { CrusadeRails::UserSubscriptionService.new}
+    subject { CrusadeRails::UserSubscriptionService.new user_id }
 
     describe 'no previous subscription' do
       before do
@@ -101,4 +180,32 @@ describe CrusadeRails::UserSubscriptionService do
     describe 'subscription not found' do
     end
   end
+
+  describe 'authenticate' do
+    subject { CrusadeRails::UserSubscriptionService.new(user_id)}
+    let(:user_id) { 1234 }
+    let(:authenticity_token) { 'abcd' }
+
+    it 'retuns true if an entry with the same user id & authenticity token exists' do
+      CrusadeRails::UserSubscription.create user_id: user_id, authenticity_token: authenticity_token
+
+      subject.authenticate(authenticity_token).must_be_true
+    end
+
+    it 'retuns false if an entry with the same user id but different authenticity token exists' do
+      CrusadeRails::UserSubscription.create user_id: user_id, authenticity_token: "#{authenticity_token}=="
+
+      subject.authenticate(authenticity_token).must_be_false
+    end
+
+    it 'retuns false if an entry with a different user id and authenticity token exists' do
+      CrusadeRails::UserSubscription.create user_id: (user_id + 1), authenticity_token: authenticity_token
+
+      subject.authenticate(authenticity_token).must_be_false
+    end
+
+    it 'retuns false if there is no entry' do
+      subject.authenticate(authenticity_token).must_be_false
+    end
+  end
 end