Convert rspec deprecation

Author: ferhatelmas

spec/activity_spec.rb

@@ -22,15 +22,15 @@ def use_model(activity_model)
 
   def has_activity_methods
     instance = @activity_model.new
-    instance.should respond_to(:activity_actor_id)
-    instance.should respond_to(:activity_verb)
-    instance.should respond_to(:activity_target)
-    instance.should respond_to(:activity_object_id)
-    instance.should respond_to(:activity_target_id)
-    instance.should respond_to(:activity_notify)
-    instance.should respond_to(:activity_extra_data)
-    instance.should respond_to(:activity_should_sync?)
-    instance.should respond_to(:create_activity)
+    expect(instance).to respond_to(:activity_actor_id)
+    expect(instance).to respond_to(:activity_verb)
+    expect(instance).to respond_to(:activity_target)
+    expect(instance).to respond_to(:activity_object_id)
+    expect(instance).to respond_to(:activity_target_id)
+    expect(instance).to respond_to(:activity_notify)
+    expect(instance).to respond_to(:activity_extra_data)
+    expect(instance).to respond_to(:activity_should_sync?)
+    expect(instance).to respond_to(:create_activity)
   end
 
   def try_delete
@@ -61,10 +61,10 @@ def build_activity
     specify { try_delete }
     specify do
       activity = build_activity_with_location
-      activity[:to].should eq nil
-      activity[:actor].should_not eq nil
-      activity[:verb].should_not eq nil
-      activity[:object].should_not eq nil
+      expect(activity[:to]).to eq nil
+      expect(activity[:actor]).not_to eq nil
+      expect(activity[:verb]).not_to eq nil
+      expect(activity[:object]).not_to eq nil
     end
   end
 
@@ -74,27 +74,27 @@ def build_activity
     specify { try_delete }
     specify do
       activity = build_activity
-      activity[:actor].should_not eq nil
-      activity[:verb].should_not eq nil
-      activity[:object].should_not eq nil
-      activity[:target].should_not eq nil
-      activity[:parent_tweet].should eq 1
-      activity[:parent_author].should eq 2
-      activity[:to].should eq ['notification:cesar']
+      expect(activity[:actor]).not_to eq nil
+      expect(activity[:verb]).not_to eq nil
+      expect(activity[:object]).not_to eq nil
+      expect(activity[:target]).not_to eq nil
+      expect(activity[:parent_tweet]).to eq 1
+      expect(activity[:parent_author]).to eq 2
+      expect(activity[:to]).to eq ['notification:cesar']
     end
   end
 
   context 'Pin' do
     before(:all) { use_model(Pin) }
     specify { has_activity_methods }
-    specify { @activity_model.new.should respond_to(:custom_save) }
+    specify { expect(@activity_model.new).to respond_to(:custom_save) }
     specify { try_delete }
     specify do
       activity = build_activity
-      activity[:to].should eq nil
-      activity[:actor].should eq 'cesar'
-      activity[:verb].should_not eq nil
-      activity[:object].should_not eq nil
+      expect(activity[:to]).to eq nil
+      expect(activity[:actor]).to eq 'cesar'
+      expect(activity[:verb]).not_to eq nil
+      expect(activity[:object]).not_to eq nil
     end
   end
 

spec/enrich_spec.rb

@@ -24,89 +24,89 @@ def create_article
   end
 
   describe 'enricher' do
-    describe 'has default settings for enriched fields' do
+    it 'has default settings for enriched fields' do
       enricher = StreamRails::Enrich.new
-      enricher.fields.should == %i[actor object target]
+      expect(enricher.fields).to eq %i[actor object target]
     end
 
-    describe 'can add additional settings for enriched fields' do
+    it 'can add additional settings for enriched fields' do
       enricher = StreamRails::Enrich.new
       enricher.add_fields([:location])
-      enricher.fields.should == %i[actor object target location]
+      expect(enricher.fields).to eq %i[actor object target location]
     end
   end
 
   describe '.enrich_activities' do
     it 'no activities' do
-      @enricher.enrich_activities([]).should eq []
+      expect(@enricher.enrich_activities([])).to eq []
     end
 
     it 'one activity' do
       instance = create_article
       activity = instance.create_activity
       enriched_activity = @enricher.enrich_activities([activity])[0]
-      enriched_activity[:object].should eq instance
-      enriched_activity[:actor].should eq @tom
-      enriched_activity[:location].should eq @denver
-      enriched_activity[:location].name.should eq 'Denver, CO'
+      expect(enriched_activity[:object]).to eq instance
+      expect(enriched_activity[:actor]).to eq @tom
+      expect(enriched_activity[:location]).to eq @denver
+      expect(enriched_activity[:location].name).to eq 'Denver, CO'
 
-      enriched_activity.enriched?.should eq true
-      enriched_activity.not_enriched_fields.should eq []
+      expect(enriched_activity.enriched?).to eq true
+      expect(enriched_activity.not_enriched_fields).to eq []
     end
 
     it 'non model object field' do
       instance = create_article
       activity = instance.create_activity
       activity[:object] = 'Planet:42'
       enriched_activity = @enricher.enrich_activities([activity])[0]
-      enriched_activity[:object].should eq 'Planet:42'
-      enriched_activity[:actor].should eq @tom
-      enriched_activity[:location].should eq @denver
-      enriched_activity.enriched?.should eq true
+      expect(enriched_activity[:object]).to eq 'Planet:42'
+      expect(enriched_activity[:actor]).to eq @tom
+      expect(enriched_activity[:location]).to eq @denver
+      expect(enriched_activity.enriched?).to eq true
     end
 
     it 'missing model object field' do
       instance = create_article
       activity = instance.create_activity
       activity[:object] = 'User:42'
       enriched_activity = @enricher.enrich_activities([activity])[0]
-      enriched_activity[:object].should eq 'User:42'
-      enriched_activity[:actor].should eq @tom
-      enriched_activity.not_enriched_fields.should eq [:object]
-      enriched_activity.enriched?.should eq false
+      expect(enriched_activity[:object]).to eq 'User:42'
+      expect(enriched_activity[:actor]).to eq @tom
+      expect(enriched_activity.not_enriched_fields).to eq [:object]
+      expect(enriched_activity.enriched?).to eq false
     end
 
     it 'has target field' do
       instance = create_article
       activity = instance.create_activity
       activity[:target] = 'Planet:42'
       enriched_activity = @enricher.enrich_activities([activity])[0]
-      enriched_activity[:target].should eq 'Planet:42'
-      enriched_activity.enriched?.should eq true
-      enriched_activity.not_enriched_fields.should eq []
+      expect(enriched_activity[:target]).to eq 'Planet:42'
+      expect(enriched_activity.enriched?).to eq true
+      expect(enriched_activity.not_enriched_fields).to eq []
     end
 
     it 'two activity' do
       a1 = create_article
       a2 = create_article
       activities = [a1, a2].map(&:create_activity)
       enriched_activities = @enricher.enrich_activities(activities)
-      enriched_activities[0][:object].should eq a1
-      enriched_activities[1][:object].should eq a2
-      enriched_activities[0].enriched?.should eq true
-      enriched_activities[1].enriched?.should eq true
-      enriched_activities[0].not_enriched_fields.should eq []
-      enriched_activities[1].not_enriched_fields.should eq []
+      expect(enriched_activities[0][:object]).to eq a1
+      expect(enriched_activities[1][:object]).to eq a2
+      expect(enriched_activities[0].enriched?).to eq true
+      expect(enriched_activities[1].enriched?).to eq true
+      expect(enriched_activities[0].not_enriched_fields).to eq []
+      expect(enriched_activities[1].not_enriched_fields).to eq []
     end
 
     it 'aggregated activity' do
       agg1 = { 'activities' => Array.new(3) { create_article.create_activity } }
       agg2 = { 'activities' => Array.new(5) { create_article.create_activity } }
       agg3 = { 'activities' => Array.new(2) { create_article.create_activity } }
       enriched = @enricher.enrich_aggregated_activities([agg1, agg2, agg3])
-      enriched[0]['activities'].length.should eq agg1['activities'].length
-      enriched[1]['activities'].length.should eq agg2['activities'].length
-      enriched[2]['activities'].length.should eq agg3['activities'].length
+      expect(enriched[0]['activities'].length).to eq agg1['activities'].length
+      expect(enriched[1]['activities'].length).to eq agg2['activities'].length
+      expect(enriched[2]['activities'].length).to eq agg3['activities'].length
     end
 
     it 'enrich partially missing fields' do
@@ -117,8 +117,8 @@ def create_article
       activities[0][:missing] = StreamRails.create_reference(@tom)
       activities[1][:missing] = nil
       enriched = custom_enricher.enrich_activities(activities)
-      enriched[0][:missing].should eq @tom
-      enriched[1][:missing].should eq nil
+      expect(enriched[0][:missing]).to eq @tom
+      expect(enriched[1][:missing]).to eq nil
     end
   end
 end

spec/feed_manager_spec.rb

@@ -23,27 +23,27 @@ def activity_should_sync?
 
   context 'instance from StreamRails' do
     let(:feed_manager) { StreamRails.feed_manager }
-    specify { feed_manager.client.should be_an_instance_of Stream::Client }
-    specify { feed_manager.get_user_feed(1).should be_an_instance_of Stream::Feed }
-    specify { feed_manager.get_user_feed(1).id.should eq 'user:1' }
-    specify { feed_manager.get_news_feeds(1).should be_an_instance_of Hash }
-    specify { feed_manager.get_news_feeds(1)[:timeline].should be_an_instance_of Stream::Feed }
-    specify { feed_manager.get_news_feeds(1)[:timeline].id.should eq 'timeline:1' }
-    specify { feed_manager.get_news_feeds(1)[:timeline_aggregated].should be_an_instance_of Stream::Feed }
-    specify { feed_manager.get_news_feeds(1)[:timeline_aggregated].id.should eq 'timeline_aggregated:1' }
-    specify { feed_manager.get_notification_feed(1).should be_an_instance_of Stream::Feed }
-    specify { feed_manager.get_feed('flat', 1).should be_an_instance_of Stream::Feed }
+    specify { expect(feed_manager.client).to be_an_instance_of Stream::Client }
+    specify { expect(feed_manager.get_user_feed(1)).to be_an_instance_of Stream::Feed }
+    specify { expect(feed_manager.get_user_feed(1).id).to eq 'user:1' }
+    specify { expect(feed_manager.get_news_feeds(1)).to be_an_instance_of Hash }
+    specify { expect(feed_manager.get_news_feeds(1)[:timeline]).to be_an_instance_of Stream::Feed }
+    specify { expect(feed_manager.get_news_feeds(1)[:timeline].id).to eq 'timeline:1' }
+    specify { expect(feed_manager.get_news_feeds(1)[:timeline_aggregated]).to be_an_instance_of Stream::Feed }
+    specify { expect(feed_manager.get_news_feeds(1)[:timeline_aggregated].id).to eq 'timeline_aggregated:1' }
+    specify { expect(feed_manager.get_notification_feed(1)).to be_an_instance_of Stream::Feed }
+    specify { expect(feed_manager.get_feed('flat', 1)).to be_an_instance_of Stream::Feed }
   end
 
   context 'follow and unfollow' do
     context 'StreamRails disabled' do
       let(:feed_manager) { StreamRails.feed_manager }
 
       it 'should not call follow/unfollow API' do
-        feed_manager.should_not receive(:get_feed)
+        expect(feed_manager).not_to receive(:get_feed)
         feed_manager.follow_user(1, 2)
 
-        feed_manager.should_not receive(:get_feed)
+        expect(feed_manager).not_to receive(:get_feed)
         feed_manager.unfollow_user(1, 2)
       end
     end

spec/renderable_spec.rb

@@ -8,19 +8,19 @@
 
     it 'picks the template based on the verb' do
       activity = StreamRails::ActivityResult.new.from_activity('verb' => 'like')
-      @actionview.should_receive(:render).with(partial: 'activity/like', layout: nil, locals: { activity: activity, parameters: {} })
+      expect(@actionview).to receive(:render).with(partial: 'activity/like', layout: nil, locals: { activity: activity, parameters: {} })
       StreamRails::Renderable.render(activity, @actionview)
     end
 
     it 'should be able to change partial_root' do
       activity = StreamRails::ActivityResult.new.from_activity('verb' => 'like')
-      @actionview.should_receive(:render).with(partial: 'custom/like', partial_root: 'custom', layout: nil, locals: { activity: activity, parameters: { partial_root: 'custom' } })
+      expect(@actionview).to receive(:render).with(partial: 'custom/like', partial_root: 'custom', layout: nil, locals: { activity: activity, parameters: { partial_root: 'custom' } })
       StreamRails::Renderable.render(activity, @actionview, partial_root: 'custom')
     end
 
     it 'should be able to send extra context' do
       activity = StreamRails::ActivityResult.new.from_activity('verb' => 'like')
-      @actionview.should_receive(:render).with(partial: 'activity/like', tommaso: 1, layout: nil, locals: { activity: activity, parameters: { tommaso: 1 } })
+      expect(@actionview).to receive(:render).with(partial: 'activity/like', tommaso: 1, layout: nil, locals: { activity: activity, parameters: { tommaso: 1 } })
       StreamRails::Renderable.render(activity, @actionview, tommaso: 1)
     end
   end

spec/sync_policies_spec.rb

@@ -5,7 +5,7 @@
   describe 'Sequel ORM integration' do
     describe 'after create hook' do
       it 'should create an activity' do
-        SequelArticle.any_instance.should_receive(:add_to_feed)
+        expect_any_instance_of(SequelArticle).to receive(:add_to_feed)
         SequelArticle.create
       end
     end
@@ -14,7 +14,7 @@
       it 'should destroy an activity' do
         SequelArticle.any_instance.stub(:add_to_feed)
         article = SequelArticle.create
-        SequelArticle.any_instance.should_receive(:remove_from_feed)
+        expect_any_instance_of(SequelArticle).to receive(:remove_from_feed)
         article.destroy
       end
     end