user_notification 0.0.1

data/test/test_notification.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+describe 'UserNotification::Notification Rendering' do
+  describe '#text' do
+    subject { UserNotification::Notification.new(:key => 'notification.test', :parameters => {:one => 1}) }
+
+    specify '#text uses translations' do
+      subject.save
+      I18n.config.backend.store_translations(:en,
+        {:notification => {:test => '%{one} %{two}'}}
+      )
+      subject.text(:two => 2).must_equal('1 2')
+      subject.parameters.must_equal({:one => 1})
+    end
+  end
+
+  describe '#render' do
+    subject do
+      s = UserNotification::Notification.new(:key => 'notification.test', :parameters => {:one => 1})
+      s.save && s
+    end
+
+    let(:template_output) { "<strong>1, 2</strong>\n<em>notification.test, #{subject.id}</em>\n" }
+    before { @controller.view_paths << File.expand_path('../views', __FILE__) }
+
+    it 'uses view partials when available' do
+      UserNotification.set_controller(Struct.new(:current_user).new('fake'))
+      subject.render(self, :two => 2)
+      rendered.must_equal template_output + "fake\n"
+    end
+
+    it 'uses requested partial'
+
+    it 'uses view partials without controller' do
+      UserNotification.set_controller(nil)
+      subject.render(self, :two => 2)
+      rendered.must_equal template_output + "\n"
+    end
+
+    it 'provides local variables' do
+      UserNotification.set_controller(nil)
+      subject.render(self, locals: {two: 2})
+      rendered.chomp.must_equal "2"
+    end
+
+    it 'uses translations only when requested' do
+      I18n.config.backend.store_translations(:en,
+        {:notification => {:test => '%{one} %{two}'}}
+      )
+      @controller.view_paths.paths.clear
+      subject.render(self, two: 2, display: :i18n)
+      rendered.must_equal '1 2'
+    end
+
+    it "uses specified layout" do
+      UserNotification.set_controller(nil)
+      subject.render(self, :layout => "notification")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => "layouts/notification")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => :notification)
+      rendered.must_include "Here be the layouts"
+    end
+  end
+end

data/test/test_tracking.rb

@@ -0,0 +1,378 @@
+require 'test_helper'
+
+describe UserNotification::Tracked do
+  describe 'defining instance options' do
+    subject { article.new }
+    let :options do
+      { :key => 'key',
+        :params => {:a => 1},
+        :owner => User.create,
+        :recipient => User.create }
+    end
+    before(:each) { subject.notification(options) }
+    let(:notification){ subject.save; subject.notifications.last }
+
+    specify { subject.notification_key.must_be_same_as    options[:key] }
+    specify { notification.key.must_equal                 options[:key] }
+
+    specify { subject.notification_owner.must_be_same_as  options[:owner] }
+    specify { notification.owner.must_equal               options[:owner] }
+
+    specify { subject.notification_params.must_be_same_as options[:params] }
+    specify { notification.parameters.must_equal          options[:params] }
+
+    specify { subject.notification_recipient.must_be_same_as options[:recipient] }
+    specify { notification.recipient.must_equal              options[:recipient] }
+  end
+
+  it 'can be tracked and be an activist at the same time' do
+    case UserNotification.config.orm
+      when :mongoid
+        class ActivistAndTrackedArticle
+          include Mongoid::Document
+          include Mongoid::Timestamps
+          include UserNotification::Model
+
+          belongs_to :user
+
+          field :name, type: String
+          field :published, type: Boolean
+          tracked
+          activist
+        end
+      when :mongo_mapper
+        class ActivistAndTrackedArticle
+          include MongoMapper::Document
+          include UserNotification::Model
+
+          belongs_to :user
+
+          key :name, String
+          key :published, Boolean
+          tracked
+          activist
+          timestamps!
+        end
+      when :active_record
+        class ActivistAndTrackedArticle < ActiveRecord::Base
+          self.table_name = 'articles'
+          include UserNotification::Model
+          tracked
+          activist
+
+          if ::ActiveRecord::VERSION::MAJOR < 4
+            attr_accessible :name, :published, :user
+          end
+          belongs_to :user
+        end
+    end
+
+    art = ActivistAndTrackedArticle.new
+    art.save
+    art.notifications.last.trackable_id.must_equal art.id
+    art.notifications.last.owner_id.must_equal nil
+  end
+
+  describe 'custom fields' do
+    describe 'global' do
+      it 'should resolve symbols' do
+        a = article(nonstandard: :name).new(name: 'Symbol resolved')
+        a.save
+        a.notifications.last.nonstandard.must_equal 'Symbol resolved'
+      end
+
+      it 'should resolve procs' do
+        a = article(nonstandard: proc {|_, model| model.name}).new(name: 'Proc resolved')
+        a.save
+        a.notifications.last.nonstandard.must_equal 'Proc resolved'
+      end
+    end
+
+    describe 'instance' do
+      it 'should resolve symbols' do
+        a = article.new(name: 'Symbol resolved')
+        a.notification nonstandard: :name
+        a.save
+        a.notifications.last.nonstandard.must_equal 'Symbol resolved'
+      end
+
+      it 'should resolve procs' do
+        a = article.new(name: 'Proc resolved')
+        a.notification nonstandard: proc {|_, model| model.name}
+        a.save
+        a.notifications.last.nonstandard.must_equal 'Proc resolved'
+      end
+    end
+  end
+
+  it 'should reset instance options on successful create_notification' do
+    a = article.new
+    a.notification key: 'test', params: {test: 1}
+    a.save
+    a.notifications.count.must_equal 1
+    ->{a.create_notification}.must_raise UserNotification::NoKeyProvided
+    a.notification_params.must_be_empty
+    a.notification key: 'asd'
+    a.create_notification
+    ->{a.create_notification}.must_raise UserNotification::NoKeyProvided
+  end
+
+  it 'should not accept global key option' do
+    # this example tests the lack of presence of sth that should not be here
+    a = article(key: 'asd').new
+    a.save
+    ->{a.create_notification}.must_raise UserNotification::NoKeyProvided
+    a.notifications.count.must_equal 1
+  end
+
+  it 'should not change global custom fields' do
+    a = article(nonstandard: 'global').new
+    a.notification nonstandard: 'instance'
+    a.save
+    a.class.notification_custom_fields_global.must_equal nonstandard: 'global'
+  end
+
+  describe 'disabling functionality' do
+    it 'allows for global disable' do
+      UserNotification.enabled = false
+      notification_count_before = UserNotification::Notification.count
+
+      @article = article().new
+      @article.save
+      UserNotification::Notification.count.must_equal notification_count_before
+
+      UserNotification.enabled = true
+    end
+
+    it 'allows for class-wide disable' do
+      notification_count_before = UserNotification::Notification.count
+
+      klass = article
+      klass.user_notification_off
+      @article = klass.new
+      @article.save
+      UserNotification::Notification.count.must_equal notification_count_before
+
+      klass.user_notification_on
+      @article.save
+      UserNotification::Notification.count.must_be :>, notification_count_before
+    end
+  end
+
+  describe '#tracked' do
+    subject { article(options) }
+    let(:options) { {} }
+
+    it 'allows skipping the tracking on CRUD actions' do
+      case UserNotification.config.orm
+        when :mongoid
+          art = Class.new do
+            include Mongoid::Document
+            include Mongoid::Timestamps
+            include UserNotification::Model
+
+            belongs_to :user
+
+            field :name, type: String
+            field :published, type: Boolean
+            tracked :skip_defaults => true
+          end
+        when :mongo_mapper
+          art = Class.new do
+            include MongoMapper::Document
+            include UserNotification::Model
+
+            belongs_to :user
+
+            key :name, String
+            key :published, Boolean
+            tracked :skip_defaults => true
+
+            timestamps!
+          end
+        when :active_record
+          art = article(:skip_defaults => true)
+      end
+
+      art.must_include UserNotification::Common
+      art.wont_include UserNotification::Creation
+      art.wont_include UserNotification::Update
+      art.wont_include UserNotification::Destruction
+    end
+
+    describe 'default options' do
+      subject { article }
+
+      specify { subject.must_include UserNotification::Creation }
+      specify { subject.must_include UserNotification::Destruction }
+      specify { subject.must_include UserNotification::Update }
+
+      specify { subject._create_callbacks.select do |c|
+        c.kind.eql?(:after) && c.filter == :notification_on_create
+      end.wont_be_empty }
+
+      specify { subject._update_callbacks.select do |c|
+        c.kind.eql?(:after) && c.filter == :notification_on_update
+      end.wont_be_empty }
+
+      specify { subject._destroy_callbacks.select do |c|
+        c.kind.eql?(:before) && c.filter == :notification_on_destroy
+      end.wont_be_empty }
+    end
+
+    it 'accepts :except option' do
+      case UserNotification.config.orm
+        when :mongoid
+          art = Class.new do
+            include Mongoid::Document
+            include Mongoid::Timestamps
+            include UserNotification::Model
+
+            belongs_to :user
+
+            field :name, type: String
+            field :published, type: Boolean
+            tracked :except => [:create]
+          end
+        when :mongo_mapper
+          art = Class.new do
+            include MongoMapper::Document
+            include UserNotification::Model
+
+            belongs_to :user
+
+            key :name, String
+            key :published, Boolean
+            tracked :except => [:create]
+
+            timestamps!
+          end
+        when :active_record
+          art = article(:except => [:create])
+      end
+
+      art.wont_include UserNotification::Creation
+      art.must_include UserNotification::Update
+      art.must_include UserNotification::Destruction
+    end
+
+    it 'accepts :only option' do
+      case UserNotification.config.orm
+        when :mongoid
+          art = Class.new do
+            include Mongoid::Document
+            include Mongoid::Timestamps
+            include UserNotification::Model
+
+            belongs_to :user
+
+            field :name, type: String
+            field :published, type: Boolean
+
+            tracked :only => [:create, :update]
+          end
+        when :mongo_mapper
+          art = Class.new do
+            include MongoMapper::Document
+            include UserNotification::Model
+
+            belongs_to :user
+
+            key :name, String
+            key :published, Boolean
+
+            tracked :only => [:create, :update]
+          end
+        when :active_record
+          art = article({:only => [:create, :update]})
+      end
+
+      art.must_include UserNotification::Creation
+      art.wont_include UserNotification::Destruction
+      art.must_include UserNotification::Update
+    end
+
+    it 'accepts :owner option' do
+      owner = mock('owner')
+      subject.tracked(:owner => owner)
+      subject.notification_owner_global.must_equal owner
+    end
+
+    it 'accepts :params option' do
+      params = {:a => 1}
+      subject.tracked(:params => params)
+      subject.notification_params_global.must_equal params
+    end
+
+    it 'accepts :on option' do
+      on = {:a => lambda{}, :b => proc {}}
+      subject.tracked(:on => on)
+      subject.notification_hooks.must_equal on
+    end
+
+    it 'accepts :on option with string keys' do
+      on = {'a' => lambda {}}
+      subject.tracked(:on => on)
+      subject.notification_hooks.must_equal on.symbolize_keys
+    end
+
+    it 'accepts :on values that are procs' do
+      on = {:unpassable => 1, :proper => lambda {}, :proper_proc => proc {}}
+      subject.tracked(:on => on)
+      subject.notification_hooks.must_include :proper
+      subject.notification_hooks.must_include :proper_proc
+      subject.notification_hooks.wont_include :unpassable
+    end
+
+    describe 'global options' do
+      subject { article(recipient: :test, owner: :test2, params: {a: 'b'}) }
+
+      specify { subject.notification_recipient_global.must_equal :test }
+      specify { subject.notification_owner_global.must_equal :test2    }
+      specify { subject.notification_params_global.must_equal(a: 'b')  }
+    end
+  end
+
+  describe 'notification hooks' do
+    subject { s = article; s.notification_hooks = {:test => hook}; s }
+    let(:hook) { lambda {} }
+
+    it 'retrieves hooks' do
+      assert_same hook, subject.get_hook(:test)
+    end
+
+    it 'retrieves hooks by string keys' do
+      assert_same hook, subject.get_hook('test')
+    end
+
+    it 'returns nil when no matching hook is present' do
+      nil.must_be_same_as subject.get_hook(:nonexistent)
+    end
+
+    it 'allows hooks to decide if notification should be created' do
+      subject.tracked
+      @article = subject.new(:name => 'Some Name')
+      UserNotification.set_controller(mock('controller'))
+      pf = proc { |model, controller|
+        controller.must_be_same_as UserNotification.get_controller
+        model.name.must_equal 'Some Name'
+        false
+      }
+      pt = proc { |model, controller|
+        controller.must_be_same_as UserNotification.get_controller
+        model.name.must_equal 'Other Name'
+        true # this will save the notification with *.update key
+      }
+      @article.class.notification_hooks = {:create => pf, :update => pt, :destroy => pt}
+
+      @article.notifications.to_a.must_be_empty
+      @article.save # create
+      @article.name = 'Other Name'
+      @article.save # update
+      @article.destroy # destroy
+
+      @article.notifications.count.must_equal 2
+      @article.notifications.first.key.must_equal 'article.update'
+    end
+  end
+end

data/test/test_view_helpers.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+describe 'ViewHelpers Rendering' do
+  include UserNotification::ViewHelpers
+
+  # is this a proper test?
+  it 'provides render_notification helper' do
+    notification = mock('notification')
+    notification.stubs(:is_a?).with(UserNotification::Notification).returns(true)
+    notification.expects(:render).with(self, {})
+    render_notification(notification)
+  end
+
+  it 'handles multiple notifications' do
+    notification = mock('notification')
+    notification.expects(:render).with(self, {})
+    render_notifications([notification])
+  end
+
+  it 'flushes content_for between partials renderes' do
+    @view_flow = mock('view_flow')
+    @view_flow.expects(:set).twice.with('name', ActiveSupport::SafeBuffer.new)
+
+    single_content_for('name', 'content')
+    @name.must_equal 'name'
+    @content.must_equal 'content'
+    single_content_for('name', 'content2')
+    @name.must_equal 'name'
+    @content.must_equal 'content2'
+  end
+
+  def content_for(name, content, &block)
+    @name = name
+    @content = content
+  end
+end

data/test/views/layouts/_notification.erb

@@ -0,0 +1 @@
+<h2>Here be the layouts</h2><%= yield %>

data/test/views/user_notification/_test.erb

@@ -0,0 +1,8 @@
+<% if defined?(two) == 'local-variable' %>
+<% # output local_variable if defined %>
+<%= two %>
+<% else %>
+<strong><%= p[:one] %>, <%= params['two'] %></strong>
+<em><%= a.key %>, <%= notification.id %></em>
+<%= current_user %>
+<% end %>