socialization 1.2.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9501a281b94d2a30d020b90075669fb384b27ffcd6fa3499afd974af90b3634
-  data.tar.gz: 183a8bc0b238e491f9d74822ad23f5777596ae0c8d536d2b0f28ce4eecd4e2b3
+  metadata.gz: 22d8b3559cb4bc0d9138ea45753f7fab5f06ba44f1b583da221612c9c3a596c6
+  data.tar.gz: 14465566e6b73fd7f4fe8d815f09987e3f4468d7e98a250fdb74e1f0a1b63f08
 SHA512:
-  metadata.gz: b2ac47b149bd84943521fdafd9ab0351caa152ab3fa23ece63d769ef63babbaf1204c390d8c2cb6984f650ec2b2ecd13301245960e425b847fadf1840b160637
-  data.tar.gz: 4bdc1e3181f17f44e34f0589e2687b48aff01da57ace6da88d499068f45a1124b963d30dce55496af58631284410d12fca9216aae70e83f3a376d32d7ba9dd09
+  metadata.gz: a3f1d7f31abb85b30943294d1b270eeca7f190ba4317e379c0f7fd4c8756b94d59a0204553d8462e781fdb6f331f448e3e565febe4c7099d32845fe9cc6c0741
+  data.tar.gz: 80ca7caf02ab9062200b1d521fcf7e8f463aa25097a988c2cea0f0f64f732f6943855043340c1b8a54dab80cc1c491be0ca95c125aff6707758483e6260ff41a

data/.github/workflows/specs.yml

@@ -0,0 +1,35 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: "*"
+  pull_request:
+    branches: "*"
+
+jobs:
+  rspec:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Install dependencies
+      run: bundle exec appraisal install
+    - name: Run tests
+      run: bundle exec appraisal rspec

data/.gitignore

@@ -11,3 +11,4 @@ doc
 .yardoc
 .rbenv-version
 gemfiles
+.byebug_history

data/.ruby-version

@@ -1 +1 @@
-2.5.0
+2.7.2

data/Appraisals

@@ -1,23 +1,7 @@
-appraise "activerecord30" do
-  gem "activerecord", "~> 3.0.10"
+appraise "activerecord614" do
+  gem "activerecord", "~> 6.1.4"
 end
 
-appraise "activerecord31" do
-  gem "activerecord", "~> 3.1.1"
-end
-
-appraise "activerecord32" do
-  gem "activerecord", "~> 3.2.1"
-end
-
-appraise "activerecord40" do
-  gem "activerecord", "~> 4.0.13"
-end
-
-appraise "activerecord41" do
-  gem "activerecord", "~> 4.1.12"
-end
-
-appraise "activerecord42" do
-  gem "activerecord", "~> 4.2.3"
+appraise "activerecord702" do
+  gem "activerecord", "~> 7.0.2"
 end

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 2.0.1 (February 18, 2022)
+
+* Added support for namespaced models (thanks @marciotoze, @twrk, @mensfeld)
+
+## 2.0.0 (February 18, 2022)
+
+* Dropped support for old Rails versions. Updated CI.
+* BREAKING CHANGE (maybe): calling `followers`, `followables`, `likers`, `likeables`, `mentioners`, `mentionables` now returns `ActiveRecord::Relation` instead of an `Array`
+
+## 1.2.3 (April 17, 2019)
+
+* Rename `victim` methods to `subject` internally. Thanks to @jdugarte for the suggestion.
+
+## 1.2.2 (April 17, 2019)
+
+* Drop support for some old Ruby versions
+
 ## 1.2.1 (April 13, 2018)
 
 * You thought this project was dead huh!?

data/README.md

@@ -8,12 +8,11 @@ The Like feature works just like a Facebook Like. For example, John likes Pulp F
 
 The Mention feature was written with Facebook mentions in mind. For example, John mentions Jane in a comment. Typically, Jane would be highlighted in the comment user interface and possibly notified that John mentioned her. This Facebook feature is occasionally called Tagging, although tagging is generally something [entirely different](http://en.wikipedia.org/wiki/Tag_(metadata).
 
-[![Build Status](https://secure.travis-ci.org/cmer/socialization.png?branch=master)](http://travis-ci.org/cmer/socialization)
+![Specs](https://github.com/cmer/socialization/actions/workflows/specs.yml/badge.svg)
+[![Gem Version](https://badge.fury.io/rb/socialization.svg)](https://badge.fury.io/rb/socialization)
 
 ## Installation
 
-### Rails 3/4
-
 Add the gem to the gemfile:
 `gem "socialization"`
 
@@ -25,9 +24,9 @@ Or if you want to use Redis as your data store:
 
 This will generate three migration files (when using ActiveRecord) and three models named Follow, Like and Mention. You may delete any of the Follow, Like or Mention models and migrations if you don't need that functionality in your application.
 
-### Rails 2.3.x Support
+### Legacy Rails Support
 
-This gem requires Rails 3 or better. Sorry!
+This gem requires Rails 6 or better. Sorry!
 
 ## Usage
 
@@ -264,22 +263,6 @@ You can find the compiled YARD documentation at http://rubydoc.info/github/cmer/
 
 ***
 
-## Changelog
-
-Here it is: https://github.com/cmer/socialization/blob/master/CHANGELOG.md
-
-## Demo App
-
-For your convenience, I have added a demo app in demo/demo_app. It does not have a web UI, but you can play with Socialization in the Rails console. It should also help you figure out hown to use Socialization in the Real World.
-
-To use the demo app:
-
-    $ cd demo/demo_app
-    $ bundle
-    $ rake db:migrate
-    $ rake db:seed
-    $ rails console
-
 
 ## Note on Patches/Pull Requests
 
@@ -295,4 +278,4 @@ To use the demo app:
 
 ## Copyright
 
-Copyright (c) 2012-2015 Carl Mercier --  Released under the MIT license.
+Copyright (c) 2012-2022 Carl Mercier --  Released under the MIT license.

data/lib/socialization/stores/active_record/follow.rb

@@ -9,12 +9,12 @@ module Socialization
       belongs_to :followable, :polymorphic => true
 
       scope :followed_by, lambda { |follower| where(
-        :follower_type   => follower.class.table_name.classify,
+        :follower_type   => follower.class.name.classify,
         :follower_id     => follower.id)
       }
 
       scope :following,   lambda { |followable| where(
-        :followable_type => followable.class.table_name.classify,
+        :followable_type => followable.class.name.classify,
         :followable_id   => followable.id)
       }
 
@@ -54,7 +54,7 @@ module Socialization
         def followers_relation(followable, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:follower_id).
-              where(:follower_type => klass.table_name.classify).
+              where(:follower_type => klass.name.classify).
               where(:followable_type => followable.class.to_s).
               where(:followable_id => followable.id)
           )
@@ -68,19 +68,14 @@ module Socialization
 
         # Returns all the followers of a certain type that are following followable
         def followers(followable, klass, opts = {})
-          rel = followers_relation(followable, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          followers_relation(followable, klass, opts)
         end
 
         # Returns an ActiveRecord::Relation of all the followables of a certain type that are followed by follower
         def followables_relation(follower, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:followable_id).
-              where(:followable_type => klass.table_name.classify).
+              where(:followable_type => klass.name.classify).
               where(:follower_type => follower.class.to_s).
               where(:follower_id => follower.id)
           )
@@ -94,12 +89,7 @@ module Socialization
 
         # Returns all the followables of a certain type that are followed by follower
         def followables(follower, klass, opts = {})
-          rel = followables_relation(follower, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          followables_relation(follower, klass, opts)
         end
 
         # Remove all the followers for followable

data/lib/socialization/stores/active_record/like.rb

@@ -9,12 +9,12 @@ module Socialization
       belongs_to :likeable, :polymorphic => true
 
       scope :liked_by, lambda { |liker| where(
-        :liker_type    => liker.class.table_name.classify,
+        :liker_type    => liker.class.name.classify,
         :liker_id      => liker.id)
       }
 
       scope :liking,   lambda { |likeable| where(
-        :likeable_type => likeable.class.table_name.classify,
+        :likeable_type => likeable.class.name.classify,
         :likeable_id   => likeable.id)
       }
 
@@ -54,7 +54,7 @@ module Socialization
         def likers_relation(likeable, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:liker_id).
-              where(:liker_type => klass.table_name.classify).
+              where(:liker_type => klass.name.classify).
               where(:likeable_type => likeable.class.to_s).
               where(:likeable_id => likeable.id)
           )
@@ -68,19 +68,14 @@ module Socialization
 
         # Returns all the likers of a certain type that are liking  likeable
         def likers(likeable, klass, opts = {})
-          rel = likers_relation(likeable, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          likers_relation(likeable, klass, opts)
         end
 
         # Returns an ActiveRecord::Relation of all the likeables of a certain type that are liked by liker
         def likeables_relation(liker, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:likeable_id).
-              where(:likeable_type => klass.table_name.classify).
+              where(:likeable_type => klass.name.classify).
               where(:liker_type => liker.class.to_s).
               where(:liker_id => liker.id)
           )
@@ -94,12 +89,7 @@ module Socialization
 
         # Returns all the likeables of a certain type that are liked by liker
         def likeables(liker, klass, opts = {})
-          rel = likeables_relation(liker, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          likeables_relation(liker, klass, opts)
         end
 
         # Remove all the likers for likeable

data/lib/socialization/stores/active_record/mention.rb

@@ -9,12 +9,12 @@ module Socialization
       belongs_to :mentionable, :polymorphic => true
 
       scope :mentioned_by, lambda { |mentioner| where(
-        :mentioner_type   => mentioner.class.table_name.classify,
+        :mentioner_type   => mentioner.class.name.classify,
         :mentioner_id     => mentioner.id)
       }
 
       scope :mentioning,   lambda { |mentionable| where(
-        :mentionable_type => mentionable.class.table_name.classify,
+        :mentionable_type => mentionable.class.name.classify,
         :mentionable_id   => mentionable.id)
       }
 
@@ -54,7 +54,7 @@ module Socialization
         def mentioners_relation(mentionable, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:mentioner_id).
-              where(:mentioner_type => klass.table_name.classify).
+              where(:mentioner_type => klass.name.classify).
               where(:mentionable_type => mentionable.class.to_s).
               where(:mentionable_id => mentionable.id)
           )
@@ -68,19 +68,14 @@ module Socialization
 
         # Returns all the mentioners of a certain type that are mentioning mentionable
         def mentioners(mentionable, klass, opts = {})
-          rel = mentioners_relation(mentionable, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          mentioners_relation(mentionable, klass, opts)
         end
 
         # Returns an ActiveRecord::Relation of all the mentionables of a certain type that are mentioned by mentioner
         def mentionables_relation(mentioner, klass, opts = {})
           rel = klass.where(klass.primary_key =>
             self.select(:mentionable_id).
-              where(:mentionable_type => klass.table_name.classify).
+              where(:mentionable_type => klass.name.classify).
               where(:mentioner_type => mentioner.class.to_s).
               where(:mentioner_id => mentioner.id)
           )
@@ -94,12 +89,7 @@ module Socialization
 
         # Returns all the mentionables of a certain type that are mentioned by mentioner
         def mentionables(mentioner, klass, opts = {})
-          rel = mentionables_relation(mentioner, klass, opts)
-          if rel.is_a?(ActiveRecord::Relation)
-            rel.to_a
-          else
-            rel
-          end
+          mentionables_relation(mentioner, klass, opts)
         end
 
         # Remove all the mentioners for mentionable

data/lib/socialization/stores/mixins/base.rb

@@ -2,9 +2,9 @@ module Socialization
   module Stores
     module Mixins
       module Base
-        def touch_dependents(actor, victim)
+        def touch_dependents(actor, subject)
           actor.touch if touch_actor?(actor)
-          victim.touch if touch_victim?(victim)
+          subject.touch if touch_subject?(subject)
         end
 
         def touch_actor?(actor)
@@ -12,10 +12,11 @@ module Socialization
           touch == :all || touch.to_s =~ /er$/i
         end
 
-        def touch_victim?(victim)
-          return false unless victim.respond_to?(:touch)
+        def touch_subject?(subject)
+          return false unless subject.respond_to?(:touch)
           touch == :all || touch.to_s =~ /able$/i
         end
+        alias touch_victim? touch_subject?
       end
     end
   end

data/lib/socialization/stores/redis/base.rb

@@ -4,83 +4,86 @@ module Socialization
 
       class << self
       protected
-        def actors(victim, klass, options = {})
+        def actors(subject, klass, options = {})
           if options[:pluck]
-            Socialization.redis.smembers(generate_forward_key(victim)).inject([]) do |result, element|
+            Socialization.redis.smembers(generate_forward_key(subject)).inject([]) do |result, element|
               result << element.match(/\:(\d+)$/)[1] if element.match(/^#{klass}\:/)
               result
             end
           else
-            actors_relation(victim, klass, options).to_a
+            actors_relation(subject, klass, options)
           end
         end
 
-        def actors_relation(victim, klass, options = {})
-          ids = actors(victim, klass, :pluck => :id)
+        def actors_relation(subject, klass, options = {})
+          ids = actors(subject, klass, :pluck => :id)
           klass.where("#{klass.table_name}.id IN (?)", ids)
         end
 
-        def victims_relation(actor, klass, options = {})
-          ids = victims(actor, klass, :pluck => :id)
+        def subjects_relation(actor, klass, options = {})
+          ids = subjects(actor, klass, :pluck => :id)
           klass.where("#{klass.table_name}.id IN (?)", ids)
         end
+        alias victims_relation subjects_relation
 
-        def victims(actor, klass, options = {})
+        def subjects(actor, klass, options = {})
           if options[:pluck]
             Socialization.redis.smembers(generate_backward_key(actor)).inject([]) do |result, element|
               result << element.match(/\:(\d+)$/)[1] if element.match(/^#{klass}\:/)
               result
             end
           else
-            victims_relation(actor, klass, options).to_a
+            subjects_relation(actor, klass, options)
           end
         end
+        alias victims subjects
 
-        def relation!(actor, victim, options = {})
-          unless options[:skip_check] || relation?(actor, victim)
-            Socialization.redis.sadd generate_forward_key(victim), generate_redis_value(actor)
-            Socialization.redis.sadd generate_backward_key(actor), generate_redis_value(victim)
-            call_after_create_hooks(actor, victim)
+        def relation!(actor, subject, options = {})
+          unless options[:skip_check] || relation?(actor, subject)
+            Socialization.redis.sadd generate_forward_key(subject), generate_redis_value(actor)
+            Socialization.redis.sadd generate_backward_key(actor), generate_redis_value(subject)
+            call_after_create_hooks(actor, subject)
             true
           else
             false
           end
         end
 
-        def unrelation!(actor, victim, options = {})
-          if options[:skip_check] || relation?(actor, victim)
-            Socialization.redis.srem generate_forward_key(victim), generate_redis_value(actor)
-            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(victim)
-            call_after_destroy_hooks(actor, victim)
+        def unrelation!(actor, subject, options = {})
+          if options[:skip_check] || relation?(actor, subject)
+            Socialization.redis.srem generate_forward_key(subject), generate_redis_value(actor)
+            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(subject)
+            call_after_destroy_hooks(actor, subject)
             true
           else
             false
           end
         end
 
-        def relation?(actor, victim)
-          Socialization.redis.sismember generate_forward_key(victim), generate_redis_value(actor)
+        def relation?(actor, subject)
+          Socialization.redis.sismember generate_forward_key(subject), generate_redis_value(actor)
         end
 
-        def remove_actor_relations(victim)
-          forward_key = generate_forward_key(victim)
+        def remove_actor_relations(subject)
+          forward_key = generate_forward_key(subject)
           actors = Socialization.redis.smembers forward_key
           Socialization.redis.del forward_key
           actors.each do |actor|
-            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(victim)
+            Socialization.redis.srem generate_backward_key(actor), generate_redis_value(subject)
           end
           true
         end
 
-        def remove_victim_relations(actor)
+        def remove_subject_relations(actor)
           backward_key = generate_backward_key(actor)
-          victims = Socialization.redis.smembers backward_key
+          subjects = Socialization.redis.smembers backward_key
           Socialization.redis.del backward_key
-          victims.each do |victim|
-            Socialization.redis.srem generate_forward_key(victim), generate_redis_value(actor)
+          subjects.each do |subject|
+            Socialization.redis.srem generate_forward_key(subject), generate_redis_value(actor)
           end
           true
         end
+        alias remove_victim_relations remove_subject_relations
 
 
       private
@@ -96,12 +99,12 @@ module Socialization
           end
         end
 
-        def generate_forward_key(victim)
+        def generate_forward_key(subject)
           keys = key_type_to_type_names(self)
-          if victim.is_a?(String)
-            "#{keys[0].pluralize.capitalize}:#{victim}"
+          if subject.is_a?(String)
+            "#{keys[0].pluralize.capitalize}:#{subject}"
           else
-            "#{keys[0].pluralize.capitalize}:#{victim.class}:#{victim.id}"
+            "#{keys[0].pluralize.capitalize}:#{subject.class}:#{subject.id}"
           end
         end
 

data/lib/socialization/stores/redis/follow.rb

@@ -6,15 +6,15 @@ module Socialization
       extend Socialization::RedisStores::Mixins::Base
 
       class << self
-        alias_method :follow!, :relation!;                          public :follow!
-        alias_method :unfollow!, :unrelation!;                      public :unfollow!
-        alias_method :follows?, :relation?;                         public :follows?
-        alias_method :followers_relation, :actors_relation;         public :followers_relation
-        alias_method :followers, :actors;                           public :followers
-        alias_method :followables_relation, :victims_relation;      public :followables_relation
-        alias_method :followables, :victims;                        public :followables
-        alias_method :remove_followers, :remove_actor_relations;    public :remove_followers
-        alias_method :remove_followables, :remove_victim_relations; public :remove_followables
+        alias_method :follow!, :relation!;                           public :follow!
+        alias_method :unfollow!, :unrelation!;                       public :unfollow!
+        alias_method :follows?, :relation?;                          public :follows?
+        alias_method :followers_relation, :actors_relation;          public :followers_relation
+        alias_method :followers, :actors;                            public :followers
+        alias_method :followables_relation, :subjects_relation;      public :followables_relation
+        alias_method :followables, :subjects;                        public :followables
+        alias_method :remove_followers, :remove_actor_relations;     public :remove_followers
+        alias_method :remove_followables, :remove_subject_relations; public :remove_followables
       end
 
     end

data/lib/socialization/stores/redis/like.rb

@@ -6,15 +6,15 @@ module Socialization
       extend Socialization::RedisStores::Mixins::Base
 
       class << self
-        alias_method :like!, :relation!;                          public :like!
-        alias_method :unlike!, :unrelation!;                      public :unlike!
-        alias_method :likes?, :relation?;                         public :likes?
-        alias_method :likers_relation, :actors_relation;          public :likers_relation
-        alias_method :likers, :actors;                            public :likers
-        alias_method :likeables_relation, :victims_relation;      public :likeables_relation
-        alias_method :likeables, :victims;                        public :likeables
-        alias_method :remove_likers, :remove_actor_relations;     public :remove_likers
-        alias_method :remove_likeables, :remove_victim_relations; public :remove_likeables
+        alias_method :like!, :relation!;                           public :like!
+        alias_method :unlike!, :unrelation!;                       public :unlike!
+        alias_method :likes?, :relation?;                          public :likes?
+        alias_method :likers_relation, :actors_relation;           public :likers_relation
+        alias_method :likers, :actors;                             public :likers
+        alias_method :likeables_relation, :subjects_relation;      public :likeables_relation
+        alias_method :likeables, :subjects;                        public :likeables
+        alias_method :remove_likers, :remove_actor_relations;      public :remove_likers
+        alias_method :remove_likeables, :remove_subject_relations; public :remove_likeables
       end
 
     end

data/lib/socialization/stores/redis/mention.rb

@@ -11,10 +11,10 @@ module Socialization
         alias_method :mentions?, :relation?;                         public :mentions?
         alias_method :mentioners_relation, :actors_relation;         public :mentioners_relation
         alias_method :mentioners, :actors;                           public :mentioners
-        alias_method :mentionables_relation, :victims_relation;      public :mentionables_relation
-        alias_method :mentionables, :victims;                        public :mentionables
+        alias_method :mentionables_relation, :subjects_relation;      public :mentionables_relation
+        alias_method :mentionables, :subjects;                        public :mentionables
         alias_method :remove_mentioners, :remove_actor_relations;    public :remove_mentioners
-        alias_method :remove_mentionables, :remove_victim_relations; public :remove_mentionables
+        alias_method :remove_mentionables, :remove_subject_relations; public :remove_mentionables
       end
 
     end

data/lib/socialization/version.rb

@@ -1,3 +1,3 @@
 module Socialization
-  VERSION = "1.2.1"
+  VERSION = "2.0.1"
 end

data/lib/socialization.rb

@@ -10,7 +10,7 @@
   stores/redis/base.rb
   stores/redis/**/*.rb
   actors/**/*.rb
-  victims/**/*.rb
+  subjects/**/*.rb
   helpers/**/*.rb
   config/**/*.rb
 ).each do |path|

data/socialization.gemspec

@@ -17,8 +17,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.has_rdoc = false
-
   s.add_runtime_dependency "activerecord"
 
   s.add_development_dependency "appraisal"
@@ -30,4 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mock_redis"
   s.add_development_dependency "guard"
   s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "byebug"
 end

data/spec/actors/liker_spec.rb

@@ -47,15 +47,14 @@ describe Socialization::Liker do
     end
 
     it "unlikes when likeing" do
-      expect(@liker).to receive(:likes?).with(@likeable).once.and_return(true)
-      expect(@liker).to receive(:unlike!).with(@likeable).once
+      @liker.like!(@likeable)
       @liker.toggle_like!(@likeable)
+      expect(@liker.likes?(@likeable)).to be false
     end
 
     it "likes when not likeing" do
-      expect(@liker).to receive(:likes?).with(@likeable).once.and_return(false)
-      expect(@liker).to receive(:like!).with(@likeable).once
       @liker.toggle_like!(@likeable)
+      expect(@liker.likes?(@likeable)).to be true
     end
   end
 

data/spec/actors/mentioner_spec.rb

@@ -47,15 +47,14 @@ describe Socialization::Mentioner do
     end
 
     it "unmentions when mentioning" do
-      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(true)
-      expect(@mentioner).to receive(:unmention!).with(@mentionable).once
+      @mentioner.mention!(@mentionable)
       @mentioner.toggle_mention!(@mentionable)
+      expect(@mentioner.mentions?(@mentionable)).to eq false
     end
 
     it "mentions when not mentioning" do
-      expect(@mentioner).to receive(:mentions?).with(@mentionable).once.and_return(false)
-      expect(@mentioner).to receive(:mention!).with(@mentionable).once
       @mentioner.toggle_mention!(@mentionable)
+      expect(@mentioner.mentions?(@mentionable)).to eq true
     end
   end