public_activity 1.6.4 → 2.0.2

data/test/test_common.rb

@@ -4,55 +4,60 @@ 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")
+    activity = subject.create_activity!('some.key')
     assert activity.persisted?
     assert_equal 'article.some.key', activity.key
   end
@@ -63,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
@@ -167,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
@@ -182,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
       }
@@ -191,4 +197,7 @@ describe PublicActivity::Common do
     end
   end
 
+  def teardown
+    PublicActivity.set_controller(nil)
+  end
 end

data/test/test_controller_integration.rb

@@ -11,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,43 +1,31 @@
 # frozen_string_literal: true
 
-if ENV["PA_ORM"] == "active_record"
+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

data/test/test_helper.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require "rubygems"
-require "bundler"
+require 'rubygems'
+require 'bundler'
 Bundler.setup(:default, :test)
 
 if ENV['COV']
   require 'simplecov'
   SimpleCov.start do
-    add_filter "/test/"
+    add_filter '/test/'
   end
 end
-$:.unshift File.expand_path('../../lib/', __FILE__)
+$:.unshift File.expand_path('../lib', __dir__)
 require 'active_support/testing/setup_and_teardown'
 require 'public_activity'
 require 'public_activity/testing'
@@ -26,46 +26,40 @@ when :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:')
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
 
-  migrations_path = File.expand_path('../migrations', __FILE__)
+  migrations_path = File.expand_path('migrations', __dir__)
+  active_record_version = ActiveRecord.version.release
 
-  if ActiveRecord.version.release() < Gem::Version.new('5.2.0')
-    ActiveRecord::Migrator.migrate(migrations_path)
-  else
+  if active_record_version >= Gem::Version.new('6.0.0')
+    schema_path = File.expand_path('../tmp/schema.rb', File.dirname(__FILE__))
+    ActiveRecord::MigrationContext.new(migrations_path, ActiveRecord::SchemaMigration).migrate
+  elsif active_record_version >= Gem::Version.new('5.2.0')
     ActiveRecord::MigrationContext.new(migrations_path).migrate
+  else # active_record_version < Gem::Version.new('5.2.0')
+    ActiveRecord::Migrator.migrate(migrations_path)
   end
 
   $stdout = STDOUT
 
   def article(options = {})
-    klass = Class.new(ActiveRecord::Base) do
+    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
+        'Article'
       end
     end
-    klass
   end
-  class User < ActiveRecord::Base; end
 
-  if ::ActiveRecord::VERSION::MAJOR < 4
-    PublicActivity::Activity.class_eval do
-      attr_accessible :nonstandard
-    end
-  end
+  class User < ActiveRecord::Base; end
 when :mongoid
   require 'mongoid'
 
-  Mongoid.load!(File.expand_path("test/mongoid.yml"), :test)
+  Mongoid.load!(File.expand_path('test/mongoid.yml'), :test)
 
   class User
     include Mongoid::Document
@@ -102,7 +96,7 @@ when :mongoid
 when :mongo_mapper
   require 'mongo_mapper'
 
-  config = YAML.load(File.read("test/mongo_mapper.yml"))
+  config = YAML.load(File.read('test/mongo_mapper.yml'))
   MongoMapper.setup(config, :test)
 
   class User

data/test/test_testing.rb

@@ -1,36 +1,37 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-describe PublicActivity do
 
-  describe "self.with_tracking" do
+describe PublicActivity do
+  describe 'self.with_tracking' do
     after do
       PublicActivity.enabled = true
     end
-    
-    it "enables tracking inside the block" do
+
+    it 'enables tracking inside the block' do
       PublicActivity.enabled = false
 
       PublicActivity.with_tracking do
-        PublicActivity.enabled?.must_equal true
+        assert PublicActivity.enabled?
       end
     end
 
-    it "restores previous `enabled` state" do
+    it 'restores previous `enabled` state' do
       PublicActivity.enabled = false
       PublicActivity.with_tracking do
         # something
       end
-      PublicActivity.enabled?.must_equal false
+
+      assert_equal PublicActivity.enabled?, false
     end
   end
 
-  describe "self.without_tracking" do
-    it "disables tracking inside the block" do
+  describe 'self.without_tracking' do
+    it 'disables tracking inside the block' do
       PublicActivity.enabled = true
 
       PublicActivity.without_tracking do
-        PublicActivity.enabled?.must_equal false
+        assert_equal PublicActivity.enabled?, false
       end
     end
   end