eventifier 0.0.7 → 0.0.8

data/spec/helpers/eventifier/notification_helper_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Eventifier::NotificationHelper do
+  before do
+    I18n.backend.store_translations :en, :notifications => {
+      :post => {
+        :create => "{{user.name}} just created an Post - you should check it out",
+        :destroy => "{{user.name}} just deleted an Post",
+        :update => {
+          :single => "{{user.name}} made a change to their Post",
+          :multiple => "{{user.name}} made some changes to their Post",
+          :attributes => {
+            :deleted_at => "{{user.name}} deleted their Post"
+          }
+        }
+      }
+    }
+  end
+
+  describe "#notification_message" do
+    it "should return the I18n message for that event" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> just created an Post - you should check it out"
+    end
+
+    it "should return a message specific to a single change if only 1 change has been made" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"] })
+      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> made a change to their Post"
+    end
+    it "should return a message specific to a particular field change if configuration is present" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :deleted_at => [nil, Time.now] })
+      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> deleted their Post"
+    end
+
+    it "should return a message specific to multiple changes if more than 1 change has been made" do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"], :age => [55, 65] })
+      helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> made some changes to their Post"
+    end
+
+    it "should return the default I18n message if one doesn't exist" do
+      I18n.backend.reload!
+      @notification_strings = {
+        :default => {
+          :create => "{{user.name}} created a {{eventable_type}}",
+          :update => "{{user.name}} updated a {{eventable_type}}"
+        }
+      }
+      I18n.backend.store_translations :test, :notifications => @notification_strings
+      I18n.with_locale("test") do
+        event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+        helper.notification_message(event).should == "<strong class='user'>#{event.user.name}</strong> created a <strong>Post</strong>"
+      end
+    end
+  end
+
+  describe "replacing vars" do
+
+    class TestClass
+      def self.helper_method(*args); end
+      include Eventifier::NotificationHelper
+    end
+
+    let!(:helper) { TestClass.new }
+
+    describe ".replace_vars" do
+      let(:event) { Fabricate.build(:event)}
+
+      it "should replace {{stuff}} with awesome" do
+        message = "I'm really loving {{eventable.title}}"
+        helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong>"
+      end
+
+      it "should replace multiple {{stuff}} with multiple awesome" do
+        message = "I'm really loving {{eventable.title}} and all {{eventable.class.name}}s"
+        helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong> and all <strong>Post</strong>s"
+      end
+    end
+
+    describe ".load_event_for_template" do
+
+      it "should add some handy methods to an event instance" do
+        event = Fabricate(:event)
+        event = helper.load_event_for_template event
+        event.object.should == event.eventable
+        event.object_type.should == event.eventable_type
+      end
+
+    end
+  end
+
+  describe ".event_message" do
+    let(:verb) { "update" }
+    let(:change_data) { { } }
+    let(:event) { double("Event", :verb => verb, :eventable_type => "Object", :change_data => change_data, :user => double("user", :name => "Willy")) }
+    let!(:helper) { TestClass.new }
+
+    before do
+      helper.stub :replace_vars => double("String", :html_safe => true)
+    end
+
+    subject { helper.event_message event }
+
+    context "with event verb create" do
+      let(:verb) { "create" }
+
+      it "should hit the I18n verb definition for create & destroy" do
+        I18n.should_receive(:translate).with("events.object.create", :default => :"events.default.create", "user.name" => "Willy", :"event.type" => "Object")
+
+        subject
+      end
+
+      it "should pass the I18n translation to the replace_vars method" do
+        I18n.should_receive(:translate).with("events.object.create", :default => :"events.default.create", "user.name" => "Willy", :"event.type" => "Object").and_return("A message")
+        helper.should_receive(:replace_vars).with "A message", event
+
+        subject
+      end
+    end
+
+    context "with event verb update" do
+      let(:verb) { "update" }
+
+      context "multiple updates" do
+        let(:change_data) { { :name => ["Lol", "Omg Lol"] } }
+
+        it "should specify single on the verb for the I18n definition on update when there are just a single change" do
+          I18n.should_receive(:translate).with("events.object.update.single", :default => :"events.default.update", "user.name" => "Willy", :"event.type" => "Object")
+
+          subject
+        end
+      end
+
+      context "multiple updates" do
+        let(:change_data) { { :name => ["Lol", "Omg Lol"], :address => ["old", "new"] } }
+
+        it "should specify single on the verb for the I18n definition on update when there are just a single change" do
+          I18n.should_receive(:translate).with("events.object.update.multiple", :default => :"events.default.update", "user.name" => "Willy", :"event.type" => "Object")
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe "replacing vars" do
+    describe ".replace_vars" do
+      let(:event) { Fabricate.build(:event)}
+
+      it "should replace {{stuff}} with awesome" do
+        message = "I'm really loving {{eventable.title}}"
+        helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong>"
+      end
+
+      it "should replace multiple {{stuff}} with multiple awesome" do
+        message = "I'm really loving {{eventable.title}} and all {{eventable.class.name}}s"
+        helper.replace_vars(message, event).should == "I'm really loving <strong>#{event.eventable.title}</strong> and all <strong>Post</strong>s"
+      end
+    end
+
+    describe ".load_event_for_template" do
+      it "should add some handy methods to an event instance" do
+        event = Fabricate(:event)
+        event = helper.load_event_for_template event
+        event.object.should == event.eventable
+        event.object_type.should == event.eventable_type
+      end
+    end
+  end
+end

data/spec/helpers/eventifier/path_helper_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Eventifier::PathHelper do
+  let(:notification) { double(Eventifier::Notification, event: double(Eventifier::Event, eventable_type: 'AwesomeObject')) }
+
+  describe "partial_path" do
+    it "returns an app view path with context in the path" do
+      helper.partial_path(notification, :donkey).should == 'eventifier/donkey/notification'
+    end
+
+    it "returns an app view if it's defined" do
+      helper.partial_path(notification, :dropdown).should == 'eventifier/dropdown/awesome_object'
+    end
+
+    it "returns the default view if not defined" do
+      helper.partial_path(notification).should == 'eventifier/notification'
+    end
+  end
+end

data/spec/integration/eventifier_spec.rb

@@ -1,108 +1,151 @@
 require 'spec_helper'
 
 describe Eventifier do
-  let(:post) { Fabricate(:post, :author => owner) }
-  let(:owner) { Fabricate(:user) }
-  let(:reader1) { Fabricate(:user) }
-  let(:reader2) { Fabricate(:user) }
-
+  it "can list tracked classes" do
+    Object.new.extend(Eventifier::EventTracking).events_for Post do
+      track_on [:create, :update], :attributes => { :except => %w(updated_at) }
+      notify :readers, :on => [:create, :update]
+    end
 
-  let(:event_tracker) { Object.new.extend(Eventifier::EventTracking) }
+    Eventifier.tracked_classes.should == [Post]
+  end
+end
 
+describe 'event tracking' do
+  let(:owner)         { Fabricate(:user) }
+  let(:reader1)       { Fabricate(:user) }
+  let(:reader2)       { Fabricate(:user) }
 
   before do
-    Eventifier::NotificationMailer.any_instance.stub main_app: double('app', url_for: true)
-    post.stub(:readers => [owner, reader1, reader2])
+    ActionMailer::Base.deliveries.clear
+
+    post.readers = [owner, reader1, reader2]
 
-    event_tracker.events_for Post do
+    Object.new.extend(Eventifier::EventTracking).events_for Post do
       track_on [:create, :update], :attributes => { :except => %w(updated_at) }
       notify :readers, :on => [:create, :update]
     end
   end
 
   context 'a new post' do
-    let(:post) { Fabricate.build(:post, :author => owner) }
+    let(:post)  { Fabricate.build(:post, :author => owner) }
+    let(:event) {
+      Eventifier::Event.where(
+        :verb => :create,          :user_id => owner.id,
+        :eventable_type => 'Post', :eventable_id => post.id
+      ).first
+    }
+
+    it "logs an event" do
+      post.save
 
-    it "notifies only the readers of the post" do
-      Eventifier::Notification.should_receive(:create).twice do |args|
-        args[:event].verb.should == :create
-        [reader1, reader2].should include(args[:user])
-      end
+      event.should be_present
+    end
+
+    it "does not store a notification for the post creator" do
       post.save
+
+      Eventifier::Notification.where(
+        :event_id => event.id, :user_id => owner.id
+      ).count.should == 0
     end
-  end
 
-  context 'an existing post' do
-    let(:post) { Fabricate(:post, :author => owner) }
-    let(:event) { Eventifier::Event.new :eventable => post, :verb => :update,
-                                        :user => owner }
-
-    it "notifies the readers of the post" do
-      Eventifier::Notification.should_receive(:create).twice do |args|
-        args[:event].verb.should == :update
-        [reader1, reader2].should include(args[:user])
+    it "stores notifications for the reader" do
+      post.save
+
+      [reader1, reader2].each do |reader|
+        Eventifier::Notification.where(
+          :event_id => event.id, :user_id => reader.id
+        ).count.should == 1
       end
-      post.update_attribute(:title, 'something else')
     end
 
-    it "should create a notification for readers of a post when it's changed" do
-      lambda { post.update_attribute(:title, 'somethang') }.should change(reader1.notifications, :count).by(1)
-    end
-  end
+    it "emails the readers with a notification" do
+      post.save
 
-  context "helper method" do
+      Eventifier::Delivery.deliver
 
-    class TestClass
-      def self.helper_method(*args)
+      [reader1, reader2].each do |reader|
+        ActionMailer::Base.deliveries.detect { |email|
+          email.to      == [reader.email] &&
+          email.subject == 'You have received notifications'
+        }.should be_present
       end
+    end
+
+    it "stores the post as the groupable object" do
+      post.save
 
-      include Eventifier::EventHelper
+      event.groupable.should == post
     end
 
-    let!(:helper) { TestClass.new }
-    before do
-      @event_strings = {
-        :post => {
-          :create => "{{user.name}} just created a new post - you should check it out",
-          :destroy => "{{user.name}} just deleted a post",
-          :update => {
-            :single => "{{user.name}} made a change to their post",
-            :multiple => "{{user.name}} made some changes to their post"
-          }
-        }
-      }
-      I18n.backend.store_translations :en, :events => @event_strings
+    it "deletes the event when the post is destroyed" do
+      post.save
+      post.destroy
+
+      Eventifier::Event.count.should be_zero
     end
 
-    it "should return the I18n message for that event" do
-      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
-      helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> just created a new post - you should check it out"
+    it "deletes notifications belonging to an event" do
+      post.save
+      post.destroy
+
+      Eventifier::Notification.count.should be_zero
     end
+  end
 
-    it "should return a message specific to a single change if only 1 change has been made" do
-      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"] })
-      helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> made a change to their post"
+  context 'an existing post' do
+    let(:post)  { Fabricate(:post, :author => owner) }
+    let(:event) {
+      Eventifier::Event.where(
+        :verb => :update,          :user_id => owner.id,
+        :eventable_type => 'Post', :eventable_id => post.id
+      ).first
+    }
+
+    it "logs an event" do
+      post.update_attribute :title, 'somethang'
+
+      event.should be_present
     end
 
-    it "should return a message specific to multiple changes if more than 1 change has been made" do
-      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"], :age => [55, 65] })
-      helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> made some changes to their post"
+    it "does not store a notification for the post creator" do
+      post.update_attribute(:title, 'something else')
+
+      Eventifier::Notification.where(
+        :event_id => event.id, :user_id => owner.id
+      ).count.should == 0
     end
 
-    it "should return the default I18n message if one doesn't exist" do
-      I18n.backend.reload!
-      @event_strings = {
-        :default => {
-          :create => "{{user.name}} created a {{eventable_type}}",
-          :update => "{{user.name}} updated a {{eventable_type}}"
-        }
-      }
-      I18n.backend.store_translations :test, :events => @event_strings
-      I18n.with_locale("test") do
-        event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
-        helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> created a <strong>Post</strong>"
+    it "stores notifications for the reader" do
+      post.update_attribute(:title, 'something else')
+
+      [reader1, reader2].each do |reader|
+        Eventifier::Notification.where(
+          :event_id => event.id, :user_id => reader.id
+        ).count.should == 1
+      end
+    end
+
+    it "should create a notification for the reader when it's changed" do
+      post.update_attribute(:title, 'somethang')
+
+      [reader1, reader2].each do |reader|
+        reader.notifications.count.should == 1
       end
     end
-  end
 
-end
+    it "emails the readers with a notification" do
+      post.update_attribute(:title, 'somethang')
+
+      Eventifier::Delivery.deliver
+
+      [reader1, reader2].each do |reader|
+        ActionMailer::Base.deliveries.detect { |email|
+          email.to      == [reader.email] &&
+          email.subject == 'You have received notifications'
+        }.should be_present
+      end
+    end
+  end
+end

data/spec/integration/internationalisation_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "Internationalisation" do
+  class TestClass
+    include Eventifier::NotificationHelper
+  end
+
+  let!(:helper) { TestClass.new }
+
+  it "should return the I18n message for that event" do
+    event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+    helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> just created a new post - you should check it out"
+  end
+
+  it "should return a message specific to a single change if only 1 change has been made" do
+    event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"] })
+    helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> made a change to their post"
+  end
+
+  it "should return a message specific to multiple changes if more than 1 change has been made" do
+    event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :update, :change_data => { :name => ["Fred", "Mike"], :age => [55, 65] })
+    helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> made some changes to their post"
+  end
+
+  it "should return the default I18n message if one doesn't exist" do
+    I18n.backend.reload!
+    I18n.backend.store_translations :test, :events => {
+      :default => {
+        :create => "{{user.name}} created a {{eventable_type}}",
+        :update => "{{user.name}} updated a {{eventable_type}}"
+      }
+    }
+
+    I18n.with_locale("test") do
+      event = Fabricate(:event, :eventable => Fabricate(:post), :verb => :create)
+      helper.event_message(event).should == "<strong class='user'>#{event.user.name}</strong> created a <strong>Post</strong>"
+    end
+  end
+end

data/spec/internal/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  #
+end

data/spec/internal/app/lib/event_tracking.rb

@@ -0,0 +1,12 @@
+class EventTracking
+  include Eventifier::EventTracking
+
+  def initialize
+    # events_for Group do
+    #   track_on [:create, :update, :destroy], :attributes => { :except => %w(updated_at) }
+    #   notify :group => :members, :on => [:create, :update]
+    # end
+  end
+end
+
+EventTracking.new

data/spec/internal/app/models/category.rb

@@ -0,0 +1,3 @@
+class Category < ActiveRecord::Base
+  has_many :posts
+end

data/spec/internal/app/models/post.rb

@@ -0,0 +1,8 @@
+class Post < ActiveRecord::Base
+  belongs_to :author, :class_name => "User"
+  belongs_to :category
+  has_many :subscriptions
+  has_many :readers, :through => :subscriptions, :source => :user
+
+  alias_method :user, :author
+end

data/spec/internal/app/models/subscription.rb

@@ -0,0 +1,4 @@
+class Subscription < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :post
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  has_many :subscriptions
+  validates :name, :presence => true, :uniqueness => true
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter:      postgresql
+  database:     eventifier
+  min_messages: warning

data/spec/internal/config/initializers/eventifier.rb

@@ -0,0 +1 @@
+Eventifier.mailer_sender = 'me@test.com'

data/spec/internal/config/locales/events.en.yml

@@ -0,0 +1,20 @@
+en:
+  events:
+    default:
+      create: "{{user.name}} created a <strong>{{object_type}}</strong>"
+      update:
+        single: "{{user.name}} updated a {{object_type}}"
+        multiple: "{{user.name}} made some changes to a {{object_type}}"
+    post:
+      create: "{{user.name}} just created a new post - you should check it out"
+      destroy: "{{user.name}} just deleted a post"
+      update:
+        single: "{{user.name}} made a change to their post"
+        multiple: "{{user.name}} made some changes to their post"
+  notifications:
+    email_subject: "You have received notifications"
+    default:
+      create: "{{user.name}} created a <strong>{{object_type}}</strong>"
+      update:
+        single: "{{user.name}} updated a {{object_type}}"
+        multiple: "{{user.name}} made some changes to a {{object_type}}"

data/spec/internal/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+  root to: 'application#index'
+
+  mount Eventifier::Engine => '/'
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,31 @@
+ActiveRecord::Schema.define do
+  create_table :categories, :force => true do |t|
+    t.string :name
+    t.timestamps
+  end
+
+  create_table :ghosts, :force => true do |t|
+    t.string  :ghost_class
+    t.integer :ghost_id
+    t.text    :data_hash
+
+    t.timestamps
+  end
+
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+    t.column :email, :string
+  end
+
+  create_table :posts, :force => true do |t|
+    t.column :title, :string
+    t.column :author_id, :integer
+    t.column :body, :text
+    t.column :category_id, :integer
+  end
+
+  create_table :subscriptions, :force => true do |t|
+    t.column :user_id, :integer
+    t.column :post_id, :integer
+  end
+end

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/models/eventifier/event_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Eventifier::Event do
+  let(:event) { Fabricate(:event) }
+
+  describe "#valid?" do
+    it_requires_a  :user
+    it_requires_an :eventable
+    it_requires_a  :verb
+  end
+
+  describe ".find_all_by_eventable" do
+    let(:eventable)  { Fabricate(:user) }
+    let(:event)      { Fabricate(:event, :eventable => eventable) }
+
+    it "should find the associated polymorphic eventable object" do
+      alpha = Fabricate :event, :eventable => eventable
+      beta  = Fabricate :event, :eventable => Fabricate(:user)
+
+      Eventifier::Event.find_all_by_eventable(eventable).should == [alpha]
+    end
+  end
+end

data/spec/{ghost_spec.rb → models/eventifier/ghost_spec.rb}

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Eventifier::Ghost do
-
   it_requires_a :ghost_class
   it_requires_a :ghost_id
   it_requires_a :data_hash
@@ -22,9 +21,10 @@ describe Eventifier::Ghost do
     subject     { Fabricate.build(:ghost, :data_hash => post.serializable_hash) }
 
     it "should be an object with the attributes of the undeleted object" do
+      pending
+
       subject.ghost.class.should == Post
       subject.ghost.attributes.except("_type").should == post.serializable_hash
     end
   end
-
-end
+end

data/spec/{notification_spec.rb → models/eventifier/notification_spec.rb}

@@ -4,7 +4,7 @@ describe Eventifier::Notification do
   let(:notification) { Fabricate(:notification) }
 
   before do
-    Eventifier::NotificationMailer.any_instance.stub main_app: double('app', url_for: true)
+    Eventifier::Mailer.any_instance.stub main_app: double('app', url_for: true)
   end
 
   describe '.expire_for_past_events!' do
@@ -47,14 +47,6 @@ describe Eventifier::Notification do
     end
   end
 
-  describe "#create" do
-    it "sends an email to the user" do
-      ActionMailer::Base.deliveries.clear
-      notification = Fabricate(:notification)
-      ActionMailer::Base.deliveries.count.should > 0
-    end
-  end
-
   describe "#unread_for?" do
     let(:user)  { double(User, :notifications_last_read_at => last_read) }
     subject     { Fabricate.build(:notification, :created_at => Time.now).unread_for?(user) }