activity_hub 0.0.1

data/test/test_activist.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe PublicActivity::Activist do
+  it 'adds owner association' do
+    klass = article
+    klass.must_respond_to :activist
+    klass.activist
+    klass.new.must_respond_to :activities
+    case ENV["PA_ORM"]
+      when "active_record"
+        klass.reflect_on_association(:activities_as_owner).options[:as].must_equal :owner
+      when "mongoid"
+        klass.reflect_on_association(:activities_as_owner).options[:inverse_of].must_equal :owner
+      when "mongo_mapper"
+        klass.associations[:activities_as_owner].options[:as].must_equal :owner
+    end
+
+    if ENV["PA_ORM"] == "mongo_mapper"
+      klass.associations[:activities_as_owner].options[:class_name].must_equal "::PublicActivity::Activity"
+    else
+      klass.reflect_on_association(:activities_as_owner).options[:class_name].must_equal "::PublicActivity::Activity"
+    end
+  end
+
+  it 'returns activities from association' do
+    case PublicActivity::Config.orm
+      when :active_record
+        class ActivistUser < ActiveRecord::Base
+          include PublicActivity::Model
+          self.table_name = 'users'
+          activist
+        end
+      when :mongoid
+        class ActivistUser
+          include Mongoid::Document
+          include PublicActivity::Model
+          activist
+
+          field :name, type: String
+        end
+      when :mongo_mapper
+        class ActivistUser
+          include MongoMapper::Document
+          include PublicActivity::Model
+          activist
+
+          key :name, String
+        end
+    end
+    owner = ActivistUser.create(:name => "Peter Pan")
+    a = article(owner: owner).new
+    a.save
+
+    owner.activities_as_owner.length.must_equal 1
+  end
+end

data/test/test_activity.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe 'PublicActivity::Activity Rendering' do
+  describe '#text' do
+    subject { PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1}) }
+
+    specify '#text uses translations' do
+      subject.save
+      I18n.config.backend.store_translations(:en,
+        {:activity => {: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 = PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1})
+      s.save && s
+    end
+
+    let(:template_output) { "<strong>1, 2</strong>\n<em>activity.test, #{subject.id}</em>\n" }
+    before { @controller.view_paths << File.expand_path('../views', __FILE__) }
+
+    it 'uses view partials when available' do
+      PublicActivity.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
+      PublicActivity.set_controller(nil)
+      subject.render(self, :two => 2)
+      rendered.must_equal template_output + "\n"
+    end
+
+    it 'provides local variables' do
+      PublicActivity.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,
+        {:activity => {:test => '%{one} %{two}'}}
+      )
+      @controller.view_paths.paths.clear
+      subject.render(self, two: 2, display: :i18n)
+      rendered.must_equal '1 2'
+    end
+
+    it "pass all params to view context" do
+      view_context = mock('ViewContext')
+      PublicActivity.set_controller(nil)
+      view_context.expects(:render).with() {|params| params[:formats] == ['json']}
+      subject.render(view_context, :formats => ['json'])
+    end
+
+    it "uses specified layout" do
+      PublicActivity.set_controller(nil)
+      subject.render(self, :layout => "activity")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => "layouts/activity")
+      rendered.must_include "Here be the layouts"
+
+      subject.render(self, :layout => :activity)
+      rendered.must_include "Here be the layouts"
+    end
+
+    it "accepts a custom layout root" do
+      subject.render(self, :layout => :layout, :layout_root => "custom")
+      rendered.must_include "Here be the custom layouts"
+    end
+    it "accepts an absolute layout path" do
+      subject.render(self, :layout => '/custom/layout')
+      rendered.must_include "Here be the custom layouts"
+    end
+    it "accepts a template root" do
+      subject.render(self, :root => "custom")
+      rendered.must_include "Custom Template Root"
+    end
+  end
+end

data/test/test_common.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe PublicActivity::Common do
+  before do
+    @owner     = User.create(:name => "Peter Pan")
+    @recipient = User.create(:name => "Bruce Wayne")
+    @options   = {:params => {:author_name => "Peter",
+                  :summary => "Default summary goes here..."},
+                  :owner => @owner, :recipient => @recipient}
+  end
+  subject { article(@options).new }
+
+  it 'prioritizes parameters passed to #create_activity' do
+    subject.save
+    subject.create_activity(:test, params: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_activity(:test, parameters: {author_name: 'Pan'}).parameters[:author_name].must_equal 'Pan'
+    subject.create_activity(:test, params: {author_name: nil}).parameters[:author_name].must_be_nil
+    subject.create_activity(:test, parameters: {author_name: nil}).parameters[:author_name].must_be_nil
+  end
+
+  it 'prioritizes owner passed to #create_activity' do
+    subject.save
+    subject.create_activity(:test, owner: @recipient).owner.must_equal @recipient
+    subject.create_activity(:test, owner: nil).owner.must_be_nil
+  end
+
+  it 'prioritizes recipient passed to #create_activity' do
+    subject.save
+    subject.create_activity(:test, recipient: @owner).recipient.must_equal @owner
+    subject.create_activity(:test, recipient: nil).recipient.must_be_nil
+  end
+
+  it 'uses global fields' do
+    subject.save
+    activity = subject.activities.last
+    activity.parameters.must_equal @options[:params]
+    activity.owner.must_equal @owner
+  end
+
+  it 'allows custom fields' do
+    subject.save
+    subject.create_activity :with_custom_fields, nonstandard: "Custom allowed"
+    subject.activities.last.nonstandard.must_equal "Custom allowed"
+  end
+
+  it '#create_activity returns a new activity object' do
+    subject.save
+    subject.create_activity("some.key").wont_be_nil
+  end
+
+  it '#create_activity! returns a new activity object' do
+    subject.save
+    activity = subject.create_activity!("some.key")
+    assert activity.persisted?
+    assert_equal 'article.some.key', activity.key
+  end
+
+  it 'update action should not create activity on save unless model changed' do
+    subject.save
+    before_count = subject.activities.count
+    subject.save
+    subject.save
+    after_count = subject.activities.count
+    before_count.must_equal after_count
+  end
+
+
+  it 'allows passing owner through #create_activity' do
+    article = article().new
+    article.save
+    activity = article.create_activity("some.key", :owner => @owner)
+    activity.owner.must_equal @owner
+  end
+
+  it 'allows resolving custom fields' do
+    subject.name      = "Resolving is great"
+    subject.published = true
+    subject.save
+    subject.create_activity :with_custom_fields, nonstandard: :name
+    subject.activities.last.nonstandard.must_equal "Resolving is great"
+    subject.create_activity :with_custom_fields_2, nonstandard: proc {|_, model| model.published.to_s}
+    subject.activities.last.nonstandard.must_equal "true"
+  end
+
+  it 'inherits instance parameters' do
+    subject.activity :params => {:author_name => "Michael"}
+    subject.save
+    activity = subject.activities.last
+
+    activity.parameters[:author_name].must_equal "Michael"
+  end
+
+  it 'accepts instance recipient' do
+    subject.activity :recipient => @recipient
+    subject.save
+    subject.activities.last.recipient.must_equal @recipient
+  end
+
+  it 'accepts instance owner' do
+    subject.activity :owner => @owner
+    subject.save
+    subject.activities.last.owner.must_equal @owner
+  end
+
+  it 'accepts owner as a symbol' do
+    klass = article(:owner => :user)
+    @article = klass.new(:user => @owner)
+    @article.save
+    activity = @article.activities.last
+
+    activity.owner.must_equal @owner
+  end
+
+  it 'reports PublicActivity::Activity as the base class' do
+    if ENV["PA_ORM"] == "active_record" # Only relevant for ActiveRecord
+      subject.save
+      subject.activities.last.class.base_class.must_equal PublicActivity::Activity
+    end
+  end
+
+  describe '#prepare_key' do
+    describe 'for class#activity_key method' do
+      before do
+        @article = article(:owner => :user).new(:user => @owner)
+      end
+
+      it 'assigns key to value of activity_key if set' do
+        def @article.activity_key; "my_custom_key" end
+
+        @article.prepare_key(:create, {}).must_equal "my_custom_key"
+      end
+
+      it 'assigns key based on class name as fallback' do
+        def @article.activity_key; nil end
+
+        @article.prepare_key(:create).must_equal "article.create"
+      end
+
+      it 'assigns key value from options hash' do
+        @article.prepare_key(:create, :key => :my_custom_key).must_equal "my_custom_key"
+      end
+    end
+
+    describe 'for camel cased classes' do
+      before do
+        class CamelCase < article(:owner => :user)
+          def self.name; 'CamelCase' end
+        end
+        @camel_case = CamelCase.new
+      end
+
+      it 'assigns generates key from class name' do
+        @camel_case.prepare_key(:create, {}).must_equal "camel_case.create"
+      end
+    end
+
+    describe 'for namespaced classes' do
+      before do
+        module ::MyNamespace;
+          class CamelCase < article(:owner => :user)
+            def self.name; 'MyNamespace::CamelCase' end
+          end
+        end
+        @namespaced_camel_case = MyNamespace::CamelCase.new
+      end
+
+      it 'assigns key value from options hash' do
+        @namespaced_camel_case.prepare_key(:create, {}).must_equal "my_namespace_camel_case.create"
+      end
+    end
+  end
+
+  # no key implicated or given
+  specify { ->{subject.prepare_settings}.must_raise PublicActivity::NoKeyProvided }
+
+  describe 'resolving values' do
+    it 'allows procs with models and controllers' do
+      context = mock('context')
+      context.expects(:accessor).times(2).returns(5)
+      controller = mock('controller')
+      controller.expects(:current_user).returns(:cu)
+      PublicActivity.set_controller(controller)
+      p = proc {|c, m|
+        assert_equal :cu, c.current_user
+        assert_equal 5, m.accessor
+      }
+      PublicActivity.resolve_value(context, p)
+      PublicActivity.resolve_value(context, :accessor)
+    end
+  end
+
+end

data/test/test_controller_integration.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class StoringController < ActionView::TestCase::TestController
+  include PublicActivity::StoreController
+  include ActionController::Testing
+end
+
+describe PublicActivity::StoreController do
+  it 'stores controller' do
+    controller = StoringController.new
+    PublicActivity.set_controller(controller)
+    controller.must_be_same_as Thread.current[:public_activity_controller]
+    controller.must_be_same_as PublicActivity.get_controller
+  end
+
+  it 'stores controller with a filter in controller' do
+    controller = StoringController.new
+    controller._process_action_callbacks.select {|c| c.kind == :around}.map(&:filter).must_include :store_controller_for_public_activity
+    controller.instance_eval do
+      store_controller_for_public_activity do
+        controller.must_be_same_as PublicActivity.get_controller
+      end
+    end
+  end
+
+  it 'stores controller in a threadsafe way' do
+    PublicActivity.set_controller(1)
+    PublicActivity.get_controller.must_equal 1
+
+    Thread.new {
+      PublicActivity.set_controller(2)
+      assert_equal 2, PublicActivity.get_controller
+      PublicActivity.set_controller(nil)
+    }
+
+    PublicActivity.get_controller.must_equal 1
+
+    PublicActivity.set_controller(nil)
+  end
+end

data/test/test_generators.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+if ENV["PA_ORM"] == "active_record"
+
+  require 'test_helper'
+  require 'rails/generators/test_case'
+  require 'generators/public_activity/migration/migration_generator'
+  require 'generators/public_activity/migration_upgrade/migration_upgrade_generator'
+
+  class TestMigrationGenerator < Rails::Generators::TestCase
+    tests PublicActivity::Generators::MigrationGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_activity_model
+      run_generator
+      assert_migration "db/migrate/create_activities.rb"
+    end
+  end
+
+  class TestMigrationUpgradeGenerator < Rails::Generators::TestCase
+    tests PublicActivity::Generators::MigrationUpgradeGenerator
+    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    setup :prepare_destination
+
+    def test_generating_activity_model
+      run_generator
+      assert_migration "db/migrate/upgrade_activities.rb"
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+if ENV['COV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/test/"
+  end
+end
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require 'active_support/testing/setup_and_teardown'
+require 'public_activity'
+require 'public_activity/testing'
+require 'pry'
+require 'minitest/autorun'
+require 'mocha/minitest'
+
+PublicActivity::Config.orm = (ENV['PA_ORM'] || :active_record)
+
+case PublicActivity::Config.orm
+when :active_record
+  require 'active_record'
+  require 'active_record/connection_adapters/sqlite3_adapter'
+  require 'stringio'        # silence the output
+  $stdout = StringIO.new    # from migrator
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+
+  migrations_path = File.expand_path('../migrations', __FILE__)
+
+  if ActiveRecord.version.release() < Gem::Version.new('5.2.0')
+    ActiveRecord::Migrator.migrate(migrations_path)
+  else
+    ActiveRecord::MigrationContext.new(migrations_path).migrate
+  end
+
+  $stdout = STDOUT
+
+  def article(options = {})
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = 'articles'
+      include PublicActivity::Model
+      tracked options
+      belongs_to :user
+
+      def self.name
+        "Article"
+      end
+
+      if ::ActiveRecord::VERSION::MAJOR < 4
+        attr_accessible :name, :published, :user
+      end
+    end
+    klass
+  end
+  class User < ActiveRecord::Base; end
+
+  if ::ActiveRecord::VERSION::MAJOR < 4
+    PublicActivity::Activity.class_eval do
+      attr_accessible :nonstandard
+    end
+  end
+when :mongoid
+  require 'mongoid'
+
+  Mongoid.load!(File.expand_path("test/mongoid.yml"), :test)
+
+  class User
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    has_many :articles
+
+    field :name, type: String
+  end
+
+  class Article
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include PublicActivity::Model
+
+    if ::Mongoid::VERSION.split('.')[0].to_i >= 7
+      belongs_to :user, optional: true
+    else
+      belongs_to :user
+    end
+
+    field :name, type: String
+    field :published, type: Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_public_activity_class_defaults
+      tracked options
+    end
+    Article
+  end
+
+when :mongo_mapper
+  require 'mongo_mapper'
+
+  config = YAML.load(File.read("test/mongo_mapper.yml"))
+  MongoMapper.setup(config, :test)
+
+  class User
+    include MongoMapper::Document
+
+    has_many :articles
+
+    key :name, String
+    timestamps!
+  end
+
+  class Article
+    include MongoMapper::Document
+    include PublicActivity::Model
+
+    belongs_to :user
+
+    key :name, String
+    key :published, Boolean
+  end
+
+  def article(options = {})
+    Article.class_eval do
+      set_public_activity_class_defaults
+      tracked options
+    end
+    Article
+  end
+end
+
+class ViewSpec < MiniTest::Spec
+  if ActiveSupport.version >= Gem::Version.new('5.2.0')
+    prepend ActiveSupport::Testing::SetupAndTeardown
+  else
+    include ActiveSupport::Testing::SetupAndTeardown
+  end
+  include ActionView::TestCase::Behavior
+end
+MiniTest::Spec.register_spec_type(/Rendering$/, ViewSpec)