activity_notification 0.0.8

data/spec/factories/articles.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :article do
+    user
+  end
+end

data/spec/factories/comments.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :comment do
+    article
+    user
+  end
+end

data/spec/factories/notifications.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :notification, class: ActivityNotification::Notification do
+    association :target, factory: :user
+    association :notifiable, factory: :article
+    key "default.default"
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :user do
+    email ['a'..'z'].shuffle.join + '@example.com'
+  end
+end

data/spec/models/notification_spec.rb

@@ -0,0 +1,259 @@
+describe ActivityNotification::Notification, type: :model do
+
+  it_behaves_like :notification_api
+
+  describe "with association" do
+    it "belongs to target" do
+      target = create(:user)
+      notification = create(:notification, target: target)
+      expect(notification.reload.target).to eq(target)
+    end
+
+    it "belongs to notifiable" do
+      notifiable = create(:article)
+      notification = create(:notification, notifiable: notifiable)
+      expect(notification.reload.notifiable).to eq(notifiable)
+    end
+
+    it "belongs to group" do
+      group = create(:article)
+      notification = create(:notification, group: group)
+      expect(notification.reload.group).to eq(group)
+    end
+
+    it "belongs to notification as group_owner" do
+      group_owner  = create(:notification, group_owner: nil)
+      group_member = create(:notification, group_owner: group_owner)
+      expect(group_member.reload.group_owner).to eq(group_owner)
+    end
+
+    it "has many notifications as group_members" do
+      group_owner  = create(:notification, group_owner: nil)
+      group_member = create(:notification, group_owner: group_owner)
+      expect(group_owner.reload.group_members.first).to eq(group_member)
+    end
+
+    it "belongs to notifier" do
+      notifier = create(:user)
+      notification = create(:notification, notifier: notifier)
+      expect(notification.reload.notifier).to eq(notifier)
+    end
+  end
+
+  describe "with serializable column" do
+    it "has parameters for hash" do
+      parameters = {a: 1, b: 2, c: 3}
+      notification = create(:notification, parameters: parameters)
+      expect(notification.reload.parameters).to eq(parameters)
+    end
+  end
+
+  describe "with validation" do
+    before { @notification = build(:notification) }
+
+    it "is valid with target, notifiable and key" do
+      expect(@notification).to be_valid
+    end
+  
+    it "is invalid with blank target" do
+      @notification.target = nil
+      expect(@notification).to be_invalid
+      expect(@notification.errors[:target].size).to eq(1)
+    end
+  
+    it "is invalid with blank notifiable" do
+      @notification.notifiable = nil
+      expect(@notification).to be_invalid
+      expect(@notification.errors[:notifiable].size).to eq(1)
+    end
+  
+    it "is invalid with blank key" do
+      @notification.key = nil
+      expect(@notification).to be_invalid
+      expect(@notification.errors[:key].size).to eq(1)
+    end
+  end
+
+  describe "with scope" do
+    context "to filter by notification status" do
+      before do
+        ActivityNotification::Notification.delete_all
+        @unopened_group_owner  = create(:notification, group_owner: nil)
+        @unopened_group_member = create(:notification, group_owner: @unopened_group_owner)
+        @opened_group_owner    = create(:notification, group_owner: nil, opened_at: DateTime.now)
+        @opened_group_member   = create(:notification, group_owner: @opened_group_owner, opened_at: DateTime.now)
+      end
+
+      it "works with group_owners_only scope" do
+        notifications = ActivityNotification::Notification.group_owners_only
+        expect(notifications.size).to eq(2)
+        expect(notifications.where(opened_at: nil).first).to eq(@unopened_group_owner)
+        expect(notifications.where.not(opened_at: nil).first).to eq(@opened_group_owner)
+      end
+  
+      it "works with group_members_only scope" do
+        notifications = ActivityNotification::Notification.group_members_only
+        expect(notifications.size).to eq(2)
+        expect(notifications.where(opened_at: nil).first).to eq(@unopened_group_member)
+        expect(notifications.where.not(opened_at: nil).first).to eq(@opened_group_member)
+      end
+  
+      it "works with unopened_only scope" do
+        notifications = ActivityNotification::Notification.unopened_only
+        expect(notifications.size).to eq(2)
+        expect(notifications.where(group_owner: nil).first).to eq(@unopened_group_owner)
+        expect(notifications.where.not(group_owner: nil).first).to eq(@unopened_group_member)
+      end
+  
+      it "works with unopened_index scope" do
+        notifications = ActivityNotification::Notification.unopened_index
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@unopened_group_owner)
+      end
+  
+      it "works with opened_only! scope" do
+        notifications = ActivityNotification::Notification.opened_only!
+        expect(notifications.size).to eq(2)
+        expect(notifications.where(group_owner: nil).first).to eq(@opened_group_owner)
+        expect(notifications.where.not(group_owner: nil).first).to eq(@opened_group_member)
+      end
+  
+      context "with opened_only scope" do
+        it "works" do
+          notifications = ActivityNotification::Notification.opened_only(4)
+          expect(notifications.size).to eq(2)
+          expect(notifications.where(group_owner: nil).first).to eq(@opened_group_owner)
+          expect(notifications.where.not(group_owner: nil).first).to eq(@opened_group_member)
+        end
+  
+        it "works with limit" do
+          notifications = ActivityNotification::Notification.opened_only(1)
+          expect(notifications.size).to eq(1)
+        end
+      end
+  
+      context "with opened_index scope" do
+        it "works" do
+          notifications = ActivityNotification::Notification.opened_index(4)
+          expect(notifications.size).to eq(1)
+          expect(notifications.first).to eq(@opened_group_owner)
+        end
+    
+        it "works with limit" do
+          notifications = ActivityNotification::Notification.opened_index(0)
+          expect(notifications.size).to eq(0)
+        end
+      end
+  
+      it "works with unopened_index_group_members_only scope" do
+        notifications = ActivityNotification::Notification.unopened_index_group_members_only
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@unopened_group_member)
+      end
+  
+      context "with opened_index_group_members_only scope" do
+        it "works" do
+          notifications = ActivityNotification::Notification.opened_index_group_members_only(4)
+          expect(notifications.size).to eq(1)
+          expect(notifications.first).to eq(@opened_group_member)
+        end
+    
+        it "works with limit" do
+          notifications = ActivityNotification::Notification.opened_index_group_members_only(0)
+          expect(notifications.size).to eq(0)
+        end
+      end
+    end
+
+    context "to filter by association" do
+      before do
+        ActivityNotification::Notification.delete_all
+        @target_1, @notifiable_1, @group_1, @key_1 = create(:user), create(:article), nil, "key.1"
+        @target_2, @notifiable_2, @group_2, @key_2 = create(:user), create(:comment), @notifiable_1, "key.2"
+        @notification_1 = create(:notification, target: @target_1, notifiable: @notifiable_1, group: @group_1, key: @key_1)
+        @notification_2 = create(:notification, target: @target_2, notifiable: @notifiable_2, group: @group_2, key: @key_2)
+      end
+
+      it "works with filtered_by_target scope" do
+        notifications = ActivityNotification::Notification.filtered_by_target(@target_1)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_1)
+        notifications = ActivityNotification::Notification.filtered_by_target(@target_2)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_2)
+      end
+
+      it "works with filtered_by_instance scope" do
+        notifications = ActivityNotification::Notification.filtered_by_instance(@notifiable_1)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_1)
+        notifications = ActivityNotification::Notification.filtered_by_instance(@notifiable_2)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_2)
+      end
+
+      it "works with filtered_by_type scope" do
+        notifications = ActivityNotification::Notification.filtered_by_type(@notifiable_1.class)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_1)
+        notifications = ActivityNotification::Notification.filtered_by_type(@notifiable_2.class)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_2)
+      end
+
+      it "works with filtered_by_group scope" do
+        notifications = ActivityNotification::Notification.filtered_by_group(@group_1)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_1)
+        notifications = ActivityNotification::Notification.filtered_by_group(@group_2)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_2)
+      end
+
+      it "works with filtered_by_key scope" do
+        notifications = ActivityNotification::Notification.filtered_by_key(@key_1)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_1)
+        notifications = ActivityNotification::Notification.filtered_by_key(@key_2)
+        expect(notifications.size).to eq(1)
+        expect(notifications.first).to eq(@notification_2)
+      end
+    end
+
+    context "to make order by created_at" do
+      before do
+        ActivityNotification::Notification.delete_all
+        unopened_group_owner   = create(:notification, group_owner: nil)
+        unopened_group_member  = create(:notification, group_owner: unopened_group_owner)
+        opened_group_owner     = create(:notification, group_owner: nil, opened_at: DateTime.now)
+        opened_group_member    = create(:notification, group_owner: opened_group_owner, opened_at: DateTime.now)
+        @earliest_notification = unopened_group_owner
+        @latest_notification   = opened_group_member
+      end
+
+      it "works with latest_order scope" do
+        notifications = ActivityNotification::Notification.latest_order
+        expect(notifications.size).to eq(4)
+        expect(notifications.first).to eq(@latest_notification)
+        expect(notifications.last).to eq(@earliest_notification)
+      end
+
+      it "works with earliest_order scope" do
+        notifications = ActivityNotification::Notification.earliest_order
+        expect(notifications.size).to eq(4)
+        expect(notifications.first).to eq(@earliest_notification)
+        expect(notifications.last).to eq(@latest_notification)
+      end
+
+      it "returns the latest notification with latest scope" do
+        notification = ActivityNotification::Notification.latest
+        expect(notification).to eq(@latest_notification)
+      end
+
+      it "returns the earliest notification with earliest scope" do
+        notification = ActivityNotification::Notification.earliest
+        expect(notification).to eq(@earliest_notification)
+      end
+    end
+  end
+end

data/spec/rails_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

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

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/rails_app/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/rails_app/app/models/article.rb

@@ -0,0 +1,12 @@
+class Article < ActiveRecord::Base
+  include ActivityNotification::Notifiable
+  acts_as_notifiable :users,
+    targets: ->(article, key) { [article.user] },
+    notifier: :user,
+    email_allowed: true#, 
+    #notifiable_path: ->(article) { concept_issue_path(issue.concept, issue) }
+
+  belongs_to :user
+  has_many :comments, dependent: :delete_all
+  has_many :commented_users, through: :comments, source: :user
+end

data/spec/rails_app/app/models/comment.rb

@@ -0,0 +1,18 @@
+class Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :user
+
+  include ActivityNotification::Notifiable
+  acts_as_notifiable :users,
+    targets: ->(comment, key) { (comment.article.commented_users.to_a - [comment.user] + [comment.article.user]).uniq },
+    group: :article,
+    notifier: :user,
+    email_allowed: :custom_notification_email_to_users_allowed?,
+    parameters: {test_default_param: '1'}#,
+    #notifiable_path: :custom_notifiable_path
+
+  def custom_notification_email_to_users_allowed?(user, key)
+    true
+  end
+
+end

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

@@ -0,0 +1,8 @@
+class User < ActiveRecord::Base
+  # devise :database_authenticatable, :registerable, :confirmable
+
+  include ActivityNotification::Target
+  acts_as_target email: :email, email_allowed: :confirmed_at
+
+  validates :email, presence: true
+end

data/spec/rails_app/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
+  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/rails_app/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/rails_app/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application', __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/rails_app/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/rails_app/bin/setup

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+# path to your application root.
+APP_ROOT = Pathname.new File.expand_path('../../',  __FILE__)
+
+Dir.chdir APP_ROOT do
+  # This script is a starting point to setup your application.
+  # Add necessary setup steps to this file:
+
+  puts "== Installing dependencies =="
+  system "gem install bundler --conservative"
+  system "bundle check || bundle install"
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   system "cp config/database.yml.sample config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system "bin/rake db:setup"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system "rm -f log/*"
+  system "rm -rf tmp/cache"
+
+  puts "\n== Restarting application server =="
+  system "touch tmp/restart.txt"
+end

data/spec/rails_app/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment', __FILE__)
+run Rails.application

data/spec/rails_app/config/application.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../boot', __FILE__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+require "sprockets/railtie"
+# require "rails/test_unit/railtie"
+
+Bundler.require(*Rails.groups)
+require "activity_notification"
+
+module Dummy
+  class Application < Rails::Application
+    # Do not swallow errors in after_commit/after_rollback callbacks.
+    config.active_record.raise_in_transactional_callbacks = true
+  end
+end
+