notifiable-rails 0.19.9 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d72a8ab45299096c3999b1f5b4636711f3abc436
-  data.tar.gz: a5c5d447002f2b6467142e0a26ee44e95f99033f
+  metadata.gz: ab6756bd2340817f2d17d834d70f8e93c1ed4099
+  data.tar.gz: 45df3fe71bb3477e904ec77b97dfebbd3df82263
 SHA512:
-  metadata.gz: 53bdb4ced5e11d073810bff0d408d69e7ef46ca0ae7c2fbc7295f48687d7a2eb3089aca448434680595e857862533d802907b8293cdbbe9786b0f9eec8fa1b34
-  data.tar.gz: 06bba839f81ee6e931fce417febaf9c55c63e87abba3fae279ab232b5fd05f43ac716d937fbe1aa821c6b781af3c9a3ac6cacb558da229557338376dce8c3989
+  metadata.gz: 315d467276e714839d3f7d82cd19698e3ca1ed7e3b91da2d86a05476bb706ef37c56b8d728f7649de9cce92ec6c6d97f169cf6472627355fca84ff6ea86330ba
+  data.tar.gz: 5904e1345423e81be5e682ee117e51122ca6263452421d2b66efcb0e4207f4d4b5e473aa2efd009d01e1fa642e171ddad4045296049c51e59f918b0f147a0911

data/Rakefile

@@ -4,21 +4,11 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Notifiable'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+Bundler::GemHelper.install_tasks
 
 APP_RAKEFILE = File.expand_path("../spec/test_app/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
-Bundler::GemHelper.install_tasks
-
 Dir[File.join(File.dirname(__FILE__), 'lib/tasks/**/*.rake')].each {|f| load f }
 
 require 'rspec/core'

data/app/controllers/notifiable/device_tokens_controller.rb

@@ -49,7 +49,7 @@ module Notifiable
       end
     
       def ensure_authorized!
-        head :status => :unauthorized if @device_token.user && current_notifiable_user && !@device_token.user.eql?(current_notifiable_user)
+        head :status => :unauthorized unless !@device_token.user || @device_token.user.eql?(current_notifiable_user)
       end
     
       def find_device_token

data/lib/notifiable/engine.rb

@@ -3,6 +3,7 @@ module Notifiable
   class Engine < ::Rails::Engine
     isolate_namespace Notifiable
     
+    # use rspec for testing
     config.generators do |g|
       g.test_framework      :rspec,        :fixture => false
       g.fixture_replacement :factory_girl, :dir => 'spec/factories'
@@ -16,6 +17,15 @@ module Notifiable
         require_dependency(c)
       end
     end
+    
+    # append migrations
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
   end
 
 end

data/lib/notifiable/version.rb

@@ -1,3 +1,3 @@
 module Notifiable
-  VERSION = "0.19.9"
+  VERSION = "0.20.0"
 end

data/spec/controllers/device_tokens_controller_spec.rb

@@ -2,137 +2,146 @@ require 'spec_helper'
 
 describe Notifiable::DeviceTokensController do
   
-  let(:user1) { FactoryGirl.create(:user) }
-  let(:user2) { FactoryGirl.create(:user_with_mock_token) }
-  let(:user2_device_token) { user2.device_tokens.first }
-  let(:app) { FactoryGirl.create(:app) }
-  let(:invalid_device_token) { FactoryGirl.create(:invalid_mock_token) }
-  
   before(:each) do
     @request.env["HTTP_ACCEPT"] = "application/json"
     @request.env["CONTENT_TYPE"] = "application/json"
   end
-
-  it "creates a new device token for an existing user" do
-    post :create, :token => "ABC123", :user_email => user1.email, :provider => :apns, :app_id => app.id
-    
-    response.status.should == 200
-    Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
-    
-    Notifiable::DeviceToken.count.should == 1
-    user1.device_tokens.count.should == 1
-    dt = user1.device_tokens.first
-    dt.token.should.eql? "ABC123"
-    dt.provider.should.eql? :apns 
-    dt.app.should.eql? app   
-  end
-  
-  it "creates a new device token for an anonymous user" do
-    post :create, :token => "ABC123", :provider => :apns, :app_id => app.id
-    
-    response.status.should == 200
-    Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
-    
-    Notifiable::DeviceToken.count.should == 1
-    dt = Notifiable::DeviceToken.first
-    dt.token.should.eql? "ABC123"
-    dt.provider.should.eql? :apns   
-    dt.app.should.eql? app
-    User.count.should == 0 
-  end
-  
-  it "uses an existing token" do
-    post :create, :token => user2_device_token.token, :provider => user2_device_token.provider, :app_id => app.id, :user_email => user2.email
-    
-    response.status.should == 200
-    Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
-    
-    Notifiable::DeviceToken.count.should == 1
-    user2.device_tokens.count.should == 1
-    dt = Notifiable::DeviceToken.first
-    dt.token.should eql user2_device_token.token
-    dt.provider.should eql user2_device_token.provider
-    dt.app.should.eql? app
-  end
-  
-  it "uses an existing token unless its invalid" do
-    post :create, :token => invalid_device_token.token, :provider => invalid_device_token.provider, :app_id => app.id, :user_email => user1.email
-    response.status.should == 200
-    Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
-    
-    Notifiable::DeviceToken.count.should == 2
-    user1.device_tokens.count.should == 1
-    dt = Notifiable::DeviceToken.last
-    dt.token.should.eql? invalid_device_token.token
-    dt.is_valid.should be_true
-  end
   
-  it "doesn't create a token if no app is specified" do
-    post :create, :token => "ABC123", :user_email => user1.email, :provider => :mpns
+  describe "#create" do
+    context "for existing user" do
+      let(:user1) { create(:user) }
+      let(:app) { create(:app) }
+      
+      before(:each) { post :create, :token => "ABC123", :user_email => user1.email, :provider => :apns, :app_id => app.id }
+      
+      it { expect(response.status).to eq 200 }
+      it { expect(json['id']).to_not be_nil }
+      it { expect(Notifiable::DeviceToken.count).to eq 1 }
+      it { expect(Notifiable::DeviceToken.first.token).to eq "ABC123" }
+      it { expect(Notifiable::DeviceToken.first.provider).to eq "apns" }
+      it { expect(Notifiable::DeviceToken.first.app).to eq app }
+      it { expect(User.first.device_tokens.count).to eq 1 }      
+    end
+    
+    context "anonymously" do
+      let(:app) { create(:app) }
+      
+      before(:each) { post :create, :token => "ABC123", :provider => :apns, :app_id => app.id }
+      
+      it { expect(response.status).to eq 200 }
+      it { expect(json['id']).to_not be_nil }
+      it { expect(Notifiable::DeviceToken.count).to eq 1 }
+      it { expect(Notifiable::DeviceToken.first.token).to eq "ABC123" }
+      it { expect(Notifiable::DeviceToken.first.provider).to eq "apns" }
+      it { expect(Notifiable::DeviceToken.first.app).to eq app }
+    end
+    
+    context "for an existing valid token" do
+      let(:app) { create(:app) }
+      let!(:token) { create(:mock_token, :token => "DEF456", :provider => :apns, :app => app) }
+      
+      before(:each) { post :create, :token => "DEF456", :provider => :apns, :app_id => app.id }
+      
+      it { expect(response.status).to eq 200 }
+      it { expect(json['id']).to eq token.id }
+      it { expect(Notifiable::DeviceToken.count).to eq 1 }
+      it { expect(Notifiable::DeviceToken.first.token).to eq "DEF456" }
+      it { expect(Notifiable::DeviceToken.first.provider).to eq "apns" }
+      it { expect(Notifiable::DeviceToken.first.app).to eq app }
+    end
+    
+    context "for an existing invalid token" do
+      let(:app) { create(:app) }
+      let!(:token) { create(:mock_token, :token => "DEF456", :provider => :apns, :app => app, :is_valid => false) }
+      
+      before(:each) { post :create, :token => "DEF456", :provider => :apns, :app_id => app.id }
+      
+      it { expect(response.status).to eq 200 }
+      it { expect(json['id']).to eq token.id }
+      it { expect(Notifiable::DeviceToken.count).to eq 1 }
+      it { expect(Notifiable::DeviceToken.first.token).to eq "DEF456" }
+      it { expect(Notifiable::DeviceToken.first.provider).to eq "apns" }
+      it { expect(Notifiable::DeviceToken.first.app).to eq app }
+      it { expect(Notifiable::DeviceToken.first.is_valid).to eq true }
+    end
+    
+    context "unless an App is specified" do      
+      before(:each) { post :create, :token => "ABC123", :provider => :apns }
+      
+      it { expect(response.status).to eq 422 }
+      it { expect(Notifiable::DeviceToken.count).to eq 0 }
+    end
     
-    response.status.should == 422
-  	Notifiable::DeviceToken.count.should == 0
   end
   
-  it "anonymises an existing token" do
+  context "old" do
+    let(:user1) { FactoryGirl.create(:user) }
+    let(:user2) { FactoryGirl.create(:user_with_mock_token) }
+    let(:user2_device_token) { user2.device_tokens.first }
+    let(:app) { FactoryGirl.create(:app) }
+    let(:invalid_device_token) { FactoryGirl.create(:invalid_mock_token) }
+
+    it "anonymises an existing token" do
     
-    post :create, :token => user2_device_token.token, :provider => :mpns
+      post :create, :token => user2_device_token.token, :provider => :mpns
     
-  	response.status.should == 200
-    Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
+    	response.status.should == 200
+      Notifiable.api_device_token_params.push('id').each{|p| json.should have_key(p.to_s)} 
     
-  	Notifiable::DeviceToken.count.should == 1
-    dt = Notifiable::DeviceToken.first
-    dt.token.should eql user2_device_token.token
-    dt.user.should be_nil
-  end
+    	Notifiable::DeviceToken.count.should == 1
+      dt = Notifiable::DeviceToken.first
+      dt.token.should eql user2_device_token.token
+      dt.user.should be_nil
+    end
   
-  it "updates token for an existing device token" do
-    put :update, :id => user2_device_token.id, :token => "DEF456", :user_email => user2.email
+    it "updates token for an existing device token" do
+      put :update, :id => user2_device_token.id, :token => "DEF456", :user_email => user2.email
 
-  	response.status.should == 200
-    Notifiable.api_device_token_params.each{|p| json.should have_key(p.to_s)} 
+    	response.status.should == 200
+      Notifiable.api_device_token_params.each{|p| json.should have_key(p.to_s)} 
     
-  	Notifiable::DeviceToken.count.should == 1
-    dt = Notifiable::DeviceToken.first
-    dt.token.should eql "DEF456"
-  end
+    	Notifiable::DeviceToken.count.should == 1
+      dt = Notifiable::DeviceToken.first
+      dt.token.should eql "DEF456"
+    end
 
-  it "deletes tokens" do
-    delete :destroy, :id => user2_device_token.id, :user_email => user2.email
+    it "deletes tokens" do
+      delete :destroy, :id => user2_device_token.id, :user_email => user2.email
     
-    expect(response).to be_success
-    Notifiable::DeviceToken.count.should == 0
-  end
+      expect(response).to be_success
+      Notifiable::DeviceToken.count.should == 0
+    end
 
-  it "doesn't delete token unless authorised" do
-  	delete :destroy, :id => user2_device_token.id
+    it "doesn't delete token unless authorised" do
+    	delete :destroy, :id => user2_device_token.id
     
-  	response.status.should == 401 
+    	response.status.should == 401 
     
-  	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
-  end
+    	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
+    end
   
-  it "doesn't delete tokens of other users" do
-  	delete :destroy, :id => user2_device_token.id, :user_email => user1.email
+    it "doesn't delete tokens of other users" do
+    	delete :destroy, :id => user2_device_token.id, :user_email => user1.email
     
-  	response.status.should == 401
+    	response.status.should == 401
     
-  	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
-  end
+    	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
+    end
   
-  it "doesnt delete tokens if they don't exist" do
-  	delete :destroy, :id => 59, :user_email => user1.email
+    it "doesnt delete tokens if they don't exist" do
+    	delete :destroy, :id => 59, :user_email => user1.email
     
-  	response.status.should == 404
-  	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
-  end
+    	response.status.should == 404
+    	Notifiable::DeviceToken.where(:token => user2_device_token.token).count.should == 1
+    end
   
-  it "doesn't update token unless authorised" do 
-    put :update, :id => user2_device_token.id, :user_email => user1.email, :token => "ZXY987"
+    it "doesn't update token unless authorised" do 
+      put :update, :id => user2_device_token.id, :user_email => user1.email, :token => "ZXY987"
         
-    response.status.should == 401
-    user2_device_token.token.should.eql? "ZXY987"
+      response.status.should == 401
+      user2_device_token.token.should.eql? "ZXY987"
+    end
+    
   end
   
 end

data/spec/controllers/notifications_controller_spec.rb

@@ -2,64 +2,64 @@ require 'spec_helper'
 
 describe Notifiable::NotificationsController do
   
-  let(:user1) { FactoryGirl.create(:user_with_mock_token) }
   let(:user1_device_token) { user1.device_tokens.first }
   let(:user2) { FactoryGirl.create(:user) }
-  let(:app) { user1_device_token.app }
-  let(:notification) { FactoryGirl.create(:notification, :app => app)}
   let(:anonymous_device_token) { FactoryGirl.create(:mock_token) }
   
   before(:each) do
     @request.env["HTTP_ACCEPT"] = "application/json"
     @request.env["CONTENT_TYPE"] = "application/json"
   end
-
-  it "marks a status as opened" do
-    FactoryGirl.create(:notification_status, :notification => notification, :device_token => user1_device_token)
-    
-    put :opened, {:notification_id => notification.id, :device_token_id => user1_device_token.id, :user_email => user1.email}
-    
-    response.status.should == 200
-    
-    Notifiable::NotificationStatus.count.should == 1
-    saved_status = Notifiable::NotificationStatus.first
-    saved_status.opened?.should be_true
-    
-    Notifiable::Notification.count.should == 1
-    saved_notification = Notifiable::Notification.first
-    saved_notification.opened_count.should == 1
-  end
   
-  it "marks a status as opened anonymously" do
-    FactoryGirl.create(:notification_status, :notification => notification, :device_token => anonymous_device_token)
-    
-    put :opened, {:notification_id => notification.id, :device_token_id => anonymous_device_token.id}
+  describe "#opened" do
     
-    response.status.should == 200
-    
-    Notifiable::NotificationStatus.count.should == 1
-    saved_status = Notifiable::NotificationStatus.first
-    saved_status.opened?.should be_true
-    
-    Notifiable::Notification.count.should == 1
-    saved_notification = Notifiable::Notification.first
-    saved_notification.opened_count.should == 1
-  end
-  
-  it "returns an error if the user is incorrect" do
-    FactoryGirl.create(:notification_status, :notification => notification, :device_token => user1_device_token)
-    
-    post :opened, {:notification_id => notification.id, :device_token_id => user1_device_token.id, :user_email => user2.email}
+    describe "by a user" do
+      
+      context "authorised" do
+        let(:notifiable_app) { create(:app) }
+        let(:user) { create(:user) }
+        let(:token) { create(:mock_token, :app => notifiable_app, :user_id => user.id) }
+        subject(:n) { create(:notification, :app => notifiable_app)}
+        let!(:status) { create(:notification_status, :notification => n, :device_token => token) }
+      
+        before(:each) { put :opened, {:notification_id => n.id, :device_token_id => token.id, :user_email => user.email} }
+      
+        it { expect(Notifiable::NotificationStatus.count).to eq 1 }
+        it { expect(Notifiable::NotificationStatus.first.opened?).to eq true }
+        it { expect(Notifiable::Notification.first.opened_count).to eq 1 }
+      end
+      
+      context "unauthorised" do
+        let(:notifiable_app) { create(:app) }
+        let(:user1) { create(:user) }
+        let(:user2) { create(:user) }
+        let(:token) { create(:mock_token, :app => notifiable_app, :user_id => user1.id) }
+        subject(:n) { create(:notification, :app => notifiable_app)}
+        let!(:status) { create(:notification_status, :notification => n, :device_token => token) }
+      
+        before(:each) { put :opened, {:notification_id => n.id, :device_token_id => token.id, :user_email => user2.email} }
+
+        it { expect(response.status).to eq 401 }      
+        it { expect(Notifiable::NotificationStatus.count).to eq 1 }
+        it { expect(Notifiable::NotificationStatus.first.opened?).to eq false }
+        it { expect(Notifiable::Notification.first.opened_count).to eq 0 }
+      end
+    end
     
-    response.status.should == 401
+    describe "anonymously" do
+      let(:notifiable_app) { create(:app) }
+      let(:token) { create(:mock_token, :app => notifiable_app) }
+      subject(:n) { create(:notification, :app => notifiable_app)}
+      let!(:status) { create(:notification_status, :notification => n, :device_token => token) }
+      
+      before(:each) { put :opened, {:notification_id => n.id, :device_token_id => token.id} }
+      
+      it { expect(Notifiable::NotificationStatus.count).to eq 1 }
+      it { expect(Notifiable::NotificationStatus.first.opened?).to eq true }
+      it { expect(Notifiable::Notification.first.opened_count).to eq 1 }      
+    end
     
-    Notifiable::NotificationStatus.count.should == 1
-    saved_status = Notifiable::NotificationStatus.first
-    saved_status.status.should == 0
     
-    Notifiable::Notification.count.should == 1
-    saved_notification = Notifiable::Notification.first
-    saved_notification.opened_count.should == 0
   end
   
 end