public_activity 1.6.3 → 2.0.1

data/test/test_activist.rb

@@ -1,56 +1,59 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 describe PublicActivity::Activist do
   it 'adds owner association' do
     klass = article
-    klass.must_respond_to :activist
+    assert_respond_to klass, :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
+    assert_respond_to klass.new, :activities
+
+    case ENV['PA_ORM']
+    when 'active_record'
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:as], :owner
+    when 'mongoid'
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:inverse_of], :owner
+    when 'mongo_mapper'
+      assert_equal klass.associations[:activities_as_owner].options[:as], :owner
     end
 
-    if ENV["PA_ORM"] == "mongo_mapper"
-      klass.associations[:activities_as_owner].options[:class_name].must_equal "::PublicActivity::Activity"
+    if ENV['PA_ORM'] == 'mongo_mapper'
+      assert_equal klass.associations[:activities_as_owner].options[:class_name], '::PublicActivity::Activity'
     else
-      klass.reflect_on_association(:activities_as_owner).options[:class_name].must_equal "::PublicActivity::Activity"
+      assert_equal klass.reflect_on_association(:activities_as_owner).options[:class_name], '::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
+    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")
+    owner = ActivistUser.create(name: 'Peter Pan')
     a = article(owner: owner).new
     a.save
 
-    owner.activities_as_owner.length.must_equal 1
+    assert_equal owner.activities_as_owner.length, 1
   end
 end

data/test/test_activity.rb

@@ -1,87 +1,88 @@
+# 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}) }
+    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})
+      I18n.config.backend.store_translations(:en, activity: { test: '%{one} %{two}' })
+      assert_equal subject.text(two: 2), '1 2'
+      assert_equal subject.parameters, one: 1
     end
   end
 
   describe '#render' do
     subject do
-      s = PublicActivity::Activity.new(:key => 'activity.test', :parameters => {:one => 1})
-      s.save && s
+      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__) }
+    before { @controller.view_paths << File.expand_path('views', __dir__) }
 
     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"
+      subject.render(self, two: 2)
+      assert_equal rendered, "#{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"
+      subject.render(self, two: 2)
+      assert_equal rendered, "#{template_output}\n"
     end
 
     it 'provides local variables' do
       PublicActivity.set_controller(nil)
-      subject.render(self, locals: {two: 2})
-      rendered.chomp.must_equal "2"
+      subject.render(self, locals: { two: 2 })
+      assert_equal rendered.chomp, '2'
     end
 
     it 'uses translations only when requested' do
-      I18n.config.backend.store_translations(:en,
-        {:activity => {:test => '%{one} %{two}'}}
-      )
+      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'
+      assert_equal rendered, '1 2'
     end
 
-    it "pass all params to view context" do
+    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'])
+      view_context.expects(:render).with { |params| params[:formats] == ['json'] }
+      subject.render(view_context, formats: ['json'])
     end
 
-    it "uses specified layout" do
+    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: 'activity')
+      assert_includes rendered, 'Here be the layouts'
 
-      subject.render(self, :layout => "layouts/activity")
-      rendered.must_include "Here be the layouts"
+      subject.render(self, layout: 'layouts/activity')
+      assert_includes rendered, 'Here be the layouts'
 
-      subject.render(self, :layout => :activity)
-      rendered.must_include "Here be the layouts"
+      subject.render(self, layout: :activity)
+      assert_includes rendered, '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"
+    it 'accepts a custom layout root' do
+      subject.render(self, layout: :layout, layout_root: 'custom')
+      assert_includes rendered, '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"
+
+    it 'accepts an absolute layout path' do
+      subject.render(self, layout: '/custom/layout')
+      assert_includes rendered, 'Here be the custom layouts'
     end
-    it "accepts a template root" do
-      subject.render(self, :root => "custom")
-      rendered.must_include "Custom Template Root"
+
+    it 'accepts a template root' do
+      subject.render(self, root: 'custom')
+      assert_includes rendered, 'Custom Template Root'
     end
   end
 end

data/test/test_common.rb

@@ -1,51 +1,65 @@
+# 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}
+    @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
+    assert_equal subject.create_activity(:test, params: { author_name: 'Pan' }).parameters[:author_name], 'Pan'
+    assert_equal subject.create_activity(:test, parameters: { author_name: 'Pan' }).parameters[:author_name], 'Pan'
+    assert_nil subject.create_activity(:test, params: { author_name: nil }).parameters[:author_name]
+    assert_nil subject.create_activity(:test, parameters: { author_name: nil }).parameters[:author_name]
   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
+    assert_equal subject.create_activity(:test, owner: @recipient).owner, @recipient
+    assert_nil subject.create_activity(:test, owner: nil).owner
   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
+    assert_equal subject.create_activity(:test, recipient: @owner).recipient, @owner
+    assert_nil subject.create_activity(:test, recipient: nil).recipient
   end
 
   it 'uses global fields' do
     subject.save
     activity = subject.activities.last
-    activity.parameters.must_equal @options[:params]
-    activity.owner.must_equal @owner
+    assert_equal activity.parameters, @options[:params]
+    assert_equal activity.owner, @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"
+    subject.create_activity :with_custom_fields, nonstandard: 'Custom allowed'
+    assert_equal subject.activities.last.nonstandard, 'Custom allowed'
   end
 
   it '#create_activity returns a new activity object' do
     subject.save
-    subject.create_activity("some.key").wont_be_nil
+    assert subject.create_activity('some.key')
+  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
@@ -54,103 +68,102 @@ describe PublicActivity::Common do
     subject.save
     subject.save
     after_count = subject.activities.count
-    before_count.must_equal after_count
+    assert_equal before_count, 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
+    activity = article.create_activity('some.key', owner: @owner)
+    assert_equal activity.owner, @owner
   end
 
   it 'allows resolving custom fields' do
-    subject.name      = "Resolving is great"
+    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"
+    assert_equal subject.activities.last.nonstandard, 'Resolving is great'
+    subject.create_activity :with_custom_fields_2, nonstandard: proc { |_, model| model.published.to_s }
+    assert_equal subject.activities.last.nonstandard, 'true'
   end
 
   it 'inherits instance parameters' do
-    subject.activity :params => {:author_name => "Michael"}
+    subject.activity params: { author_name: 'Michael' }
     subject.save
     activity = subject.activities.last
 
-    activity.parameters[:author_name].must_equal "Michael"
+    assert_equal activity.parameters[:author_name], 'Michael'
   end
 
   it 'accepts instance recipient' do
-    subject.activity :recipient => @recipient
+    subject.activity recipient: @recipient
     subject.save
-    subject.activities.last.recipient.must_equal @recipient
+    assert_equal subject.activities.last.recipient, @recipient
   end
 
   it 'accepts instance owner' do
-    subject.activity :owner => @owner
+    subject.activity owner: @owner
     subject.save
-    subject.activities.last.owner.must_equal @owner
+    assert_equal subject.activities.last.owner, @owner
   end
 
   it 'accepts owner as a symbol' do
-    klass = article(:owner => :user)
-    @article = klass.new(:user => @owner)
+    klass = article(owner: :user)
+    @article = klass.new(user: @owner)
     @article.save
     activity = @article.activities.last
 
-    activity.owner.must_equal @owner
+    assert_equal activity.owner, @owner
   end
 
   it 'reports PublicActivity::Activity as the base class' do
-    if ENV["PA_ORM"] == "active_record" # Only relevant for ActiveRecord
+    if ENV['PA_ORM'] == 'active_record' # Only relevant for ActiveRecord
       subject.save
-      subject.activities.last.class.base_class.must_equal PublicActivity::Activity
+      assert_equal subject.activities.last.class.base_class, PublicActivity::Activity
     end
   end
 
   describe '#prepare_key' do
     describe 'for class#activity_key method' do
       before do
-        @article = article(:owner => :user).new(:user => @owner)
+        @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
+        def @article.activity_key; 'my_custom_key' end
 
-        @article.prepare_key(:create, {}).must_equal "my_custom_key"
+        assert_equal @article.prepare_key(:create, {}), '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"
+        assert_equal @article.prepare_key(:create), 'article.create'
       end
 
       it 'assigns key value from options hash' do
-        @article.prepare_key(:create, :key => :my_custom_key).must_equal "my_custom_key"
+        assert_equal @article.prepare_key(:create, key: :my_custom_key), 'my_custom_key'
       end
     end
 
     describe 'for camel cased classes' do
       before do
-        class CamelCase < article(:owner => :user)
+        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"
+        assert_equal @camel_case.prepare_key(:create, {}), 'camel_case.create'
       end
     end
 
     describe 'for namespaced classes' do
       before do
         module ::MyNamespace;
-          class CamelCase < article(:owner => :user)
+          class CamelCase < article(owner: :user)
             def self.name; 'MyNamespace::CamelCase' end
           end
         end
@@ -158,13 +171,15 @@ describe PublicActivity::Common do
       end
 
       it 'assigns key value from options hash' do
-        @namespaced_camel_case.prepare_key(:create, {}).must_equal "my_namespace_camel_case.create"
+        assert_equal @namespaced_camel_case.prepare_key(:create, {}), 'my_namespace_camel_case.create'
       end
     end
   end
 
   # no key implicated or given
-  specify { ->{subject.prepare_settings}.must_raise PublicActivity::NoKeyProvided }
+  specify do
+    assert_raises(PublicActivity::NoKeyProvided) { subject.prepare_settings }
+  end
 
   describe 'resolving values' do
     it 'allows procs with models and controllers' do
@@ -173,7 +188,7 @@ describe PublicActivity::Common do
       controller = mock('controller')
       controller.expects(:current_user).returns(:cu)
       PublicActivity.set_controller(controller)
-      p = proc {|c, m|
+      p = proc { |c, m|
         assert_equal :cu, c.current_user
         assert_equal 5, m.accessor
       }
@@ -182,4 +197,7 @@ describe PublicActivity::Common do
     end
   end
 
+  def teardown
+    PublicActivity.set_controller(nil)
+  end
 end

data/test/test_controller_integration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class StoringController < ActionView::TestCase::TestController
@@ -9,31 +11,37 @@ 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
+    assert_same controller, Thread.current[:public_activity_controller]
+    assert_same controller, 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
+
+    callbacks = controller._process_action_callbacks.select { |c| c.kind == :around }.map(&:filter)
+    assert_includes(callbacks, :store_controller_for_public_activity)
+
+    public_activity_controller =
+      controller.instance_eval do
+        store_controller_for_public_activity do
+          PublicActivity.get_controller
+        end
       end
-    end
+
+    assert_equal controller, public_activity_controller
   end
 
   it 'stores controller in a threadsafe way' do
     PublicActivity.set_controller(1)
-    PublicActivity.get_controller.must_equal 1
+    assert_equal PublicActivity.get_controller, 1
 
-    Thread.new {
+    Thread.new do
       PublicActivity.set_controller(2)
       assert_equal 2, PublicActivity.get_controller
       PublicActivity.set_controller(nil)
-    }
+    end
 
-    PublicActivity.get_controller.must_equal 1
+    assert_equal PublicActivity.get_controller, 1
 
     PublicActivity.set_controller(nil)
   end

data/test/test_generators.rb

@@ -1,41 +1,31 @@
-if ENV["PA_ORM"] == "active_record"
+# frozen_string_literal: true
+
+if ENV['PA_ORM'] == 'active_record'
 
   require 'test_helper'
   require 'rails/generators/test_case'
-  require 'generators/public_activity/activity/activity_generator'
   require 'generators/public_activity/migration/migration_generator'
   require 'generators/public_activity/migration_upgrade/migration_upgrade_generator'
 
-  class TestActivityGenerator < Rails::Generators::TestCase
-    tests PublicActivity::Generators::ActivityGenerator
-    destination File.expand_path("../tmp", File.dirname(__FILE__))
-    setup :prepare_destination
-
-    def test_generating_activity_model
-      run_generator
-      assert_file "app/models/activity.rb"
-    end
-  end
-
   class TestMigrationGenerator < Rails::Generators::TestCase
     tests PublicActivity::Generators::MigrationGenerator
-    destination File.expand_path("../tmp", File.dirname(__FILE__))
+    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"
+      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__))
+    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"
+      assert_migration 'db/migrate/upgrade_activities.rb'
     end
   end
 end