few components with rspec3 syntax

spec/components/topic_query_spec.rb

@@ -20,21 +20,21 @@ describe TopicQuery do
       topic = Fabricate(:topic, category: category)
       topic = Fabricate(:topic, visible: false)
 
-      TopicQuery.new(nil).list_latest.topics.count.should == 0
-      TopicQuery.new(user).list_latest.topics.count.should == 0
+      expect(TopicQuery.new(nil).list_latest.topics.count).to eq(0)
+      expect(TopicQuery.new(user).list_latest.topics.count).to eq(0)
 
-      Topic.top_viewed(10).count.should == 0
-      Topic.recent(10).count.should == 0
+      expect(Topic.top_viewed(10).count).to eq(0)
+      expect(Topic.recent(10).count).to eq(0)
 
       # mods can see hidden topics
-      TopicQuery.new(moderator).list_latest.topics.count.should == 1
+      expect(TopicQuery.new(moderator).list_latest.topics.count).to eq(1)
       # admins can see all the topics
-      TopicQuery.new(admin).list_latest.topics.count.should == 3
+      expect(TopicQuery.new(admin).list_latest.topics.count).to eq(3)
 
       group.add(user)
       group.save
 
-      TopicQuery.new(user).list_latest.topics.count.should == 2
+      expect(TopicQuery.new(user).list_latest.topics.count).to eq(2)
 
     end
 
@@ -54,8 +54,8 @@ describe TopicQuery do
 
       query = TopicQuery.new(user, filter: 'bookmarked').list_latest
 
-      query.topics.length.should == 1
-      query.topics.first.user_data.post_action_data.should == {PostActionType.types[:bookmark] => [1,2]}
+      expect(query.topics.length).to eq(1)
+      expect(query.topics.first.user_data.post_action_data).to eq({PostActionType.types[:bookmark] => [1,2]})
     end
   end
 
@@ -63,10 +63,10 @@ describe TopicQuery do
     it "filters deleted topics correctly" do
       _topic = Fabricate(:topic, deleted_at: 1.year.ago)
 
-      TopicQuery.new(admin, status: 'deleted').list_latest.topics.size.should == 1
-      TopicQuery.new(moderator, status: 'deleted').list_latest.topics.size.should == 1
-      TopicQuery.new(user, status: 'deleted').list_latest.topics.size.should == 0
-      TopicQuery.new(nil, status: 'deleted').list_latest.topics.size.should == 0
+      expect(TopicQuery.new(admin, status: 'deleted').list_latest.topics.size).to eq(1)
+      expect(TopicQuery.new(moderator, status: 'deleted').list_latest.topics.size).to eq(1)
+      expect(TopicQuery.new(user, status: 'deleted').list_latest.topics.size).to eq(0)
+      expect(TopicQuery.new(nil, status: 'deleted').list_latest.topics.size).to eq(0)
     end
   end
 
@@ -76,27 +76,27 @@ describe TopicQuery do
     let(:diff_category) { Fabricate(:diff_category) }
 
     it "returns topics in the category when we filter to it" do
-      TopicQuery.new(moderator).list_latest.topics.size.should == 0
+      expect(TopicQuery.new(moderator).list_latest.topics.size).to eq(0)
 
       # Filter by slug
-      TopicQuery.new(moderator, category: category.slug).list_latest.topics.size.should == 1
-      TopicQuery.new(moderator, category: "#{category.id}-category").list_latest.topics.size.should == 1
+      expect(TopicQuery.new(moderator, category: category.slug).list_latest.topics.size).to eq(1)
+      expect(TopicQuery.new(moderator, category: "#{category.id}-category").list_latest.topics.size).to eq(1)
 
       list = TopicQuery.new(moderator, category: diff_category.slug).list_latest
-      list.topics.size.should == 1
-      list.preload_key.should == "topic_list_c/different-category/l/latest"
+      expect(list.topics.size).to eq(1)
+      expect(list.preload_key).to eq("topic_list_c/different-category/l/latest")
 
       # Defaults to no category filter when slug does not exist
-      TopicQuery.new(moderator, category: 'made up slug').list_latest.topics.size.should == 2
+      expect(TopicQuery.new(moderator, category: 'made up slug').list_latest.topics.size).to eq(2)
     end
 
     context 'subcategories' do
       let!(:subcategory) { Fabricate(:category, parent_category_id: category.id)}
 
       it "works with subcategories" do
-        TopicQuery.new(moderator, category: category.id).list_latest.topics.size.should == 1
-        TopicQuery.new(moderator, category: subcategory.id).list_latest.topics.size.should == 1
-        TopicQuery.new(moderator, category: category.id, no_subcategories: true).list_latest.topics.size.should == 1
+        expect(TopicQuery.new(moderator, category: category.id).list_latest.topics.size).to eq(1)
+        expect(TopicQuery.new(moderator, category: subcategory.id).list_latest.topics.size).to eq(1)
+        expect(TopicQuery.new(moderator, category: category.id, no_subcategories: true).list_latest.topics.size).to eq(1)
       end
 
     end
@@ -111,8 +111,8 @@ describe TopicQuery do
       CategoryUser.create!(user_id: user.id,
                            category_id: category.id,
                            notification_level: CategoryUser.notification_levels[:muted])
-      topic_query.list_new.topics.map(&:id).should_not include(topic.id)
-      topic_query.list_latest.topics.map(&:id).should_not include(topic.id)
+      expect(topic_query.list_new.topics.map(&:id)).not_to include(topic.id)
+      expect(topic_query.list_latest.topics.map(&:id)).not_to include(topic.id)
     end
   end
 
@@ -181,13 +181,13 @@ describe TopicQuery do
 
     context 'list_latest' do
       it "returns the topics in the correct order" do
-        topics.map(&:id).should == [pinned_topic, future_topic, closed_topic, archived_topic, regular_topic].map(&:id)
+        expect(topics.map(&:id)).to eq([pinned_topic, future_topic, closed_topic, archived_topic, regular_topic].map(&:id))
 
         # includes the invisible topic if you're a moderator
-        TopicQuery.new(moderator).list_latest.topics.include?(invisible_topic).should == true
+        expect(TopicQuery.new(moderator).list_latest.topics.include?(invisible_topic)).to eq(true)
 
         # includes the invisible topic if you're an admin" do
-        TopicQuery.new(admin).list_latest.topics.include?(invisible_topic).should == true
+        expect(TopicQuery.new(admin).list_latest.topics.include?(invisible_topic)).to eq(true)
       end
 
       context 'sort_order' do
@@ -198,28 +198,28 @@ describe TopicQuery do
 
         it "returns the topics in correct order" do
           # returns the topics in likes order if requested
-          ids_in_order('posts').should == [future_topic, pinned_topic, archived_topic, regular_topic, invisible_topic, closed_topic].map(&:id)
+          expect(ids_in_order('posts')).to eq([future_topic, pinned_topic, archived_topic, regular_topic, invisible_topic, closed_topic].map(&:id))
 
           # returns the topics in reverse likes order if requested
-          ids_in_order('posts', false).should == [closed_topic, invisible_topic, regular_topic, archived_topic, pinned_topic, future_topic].map(&:id)
+          expect(ids_in_order('posts', false)).to eq([closed_topic, invisible_topic, regular_topic, archived_topic, pinned_topic, future_topic].map(&:id))
 
           # returns the topics in likes order if requested
-          ids_in_order('likes').should == [pinned_topic, regular_topic, archived_topic, future_topic, invisible_topic, closed_topic].map(&:id)
+          expect(ids_in_order('likes')).to eq([pinned_topic, regular_topic, archived_topic, future_topic, invisible_topic, closed_topic].map(&:id))
 
           # returns the topics in reverse likes order if requested
-          ids_in_order('likes', false).should == [closed_topic, invisible_topic, future_topic, archived_topic, regular_topic, pinned_topic].map(&:id)
+          expect(ids_in_order('likes', false)).to eq([closed_topic, invisible_topic, future_topic, archived_topic, regular_topic, pinned_topic].map(&:id))
 
           # returns the topics in views order if requested
-          ids_in_order('views').should == [regular_topic, archived_topic, future_topic, pinned_topic, closed_topic, invisible_topic].map(&:id)
+          expect(ids_in_order('views')).to eq([regular_topic, archived_topic, future_topic, pinned_topic, closed_topic, invisible_topic].map(&:id))
 
           # returns the topics in reverse views order if requested" do
-          ids_in_order('views', false).should == [invisible_topic, closed_topic, pinned_topic, future_topic, archived_topic, regular_topic].map(&:id)
+          expect(ids_in_order('views', false)).to eq([invisible_topic, closed_topic, pinned_topic, future_topic, archived_topic, regular_topic].map(&:id))
 
           # returns the topics in posters order if requested" do
-          ids_in_order('posters').should == [pinned_topic, regular_topic, future_topic, invisible_topic, closed_topic, archived_topic].map(&:id)
+          expect(ids_in_order('posters')).to eq([pinned_topic, regular_topic, future_topic, invisible_topic, closed_topic, archived_topic].map(&:id))
 
           # returns the topics in reverse posters order if requested" do
-          ids_in_order('posters', false).should == [archived_topic, closed_topic, invisible_topic, future_topic, regular_topic, pinned_topic].map(&:id)
+          expect(ids_in_order('posters', false)).to eq([archived_topic, closed_topic, invisible_topic, future_topic, regular_topic, pinned_topic].map(&:id))
         end
 
       end
@@ -233,7 +233,7 @@ describe TopicQuery do
       end
 
       it "no longer shows the pinned topic at the top" do
-        topics.should == [future_topic, closed_topic, archived_topic, pinned_topic, regular_topic]
+        expect(topics).to eq([future_topic, closed_topic, archived_topic, pinned_topic, regular_topic])
       end
     end
 
@@ -246,17 +246,17 @@ describe TopicQuery do
     let!(:topic_in_cat) { Fabricate(:topic, category: category) }
 
     it "returns the topic with a category when filtering by category" do
-      topic_query.list_category(category).topics.should == [topic_category, topic_in_cat]
+      expect(topic_query.list_category(category).topics).to eq([topic_category, topic_in_cat])
     end
 
     it "returns only the topic category when filtering by another category" do
       another_category = Fabricate(:category, name: 'new cat')
-      topic_query.list_category(another_category).topics.should == [another_category.topic]
+      expect(topic_query.list_category(another_category).topics).to eq([another_category.topic])
     end
 
     describe '#list_new_in_category' do
       it 'returns the topic category and the categorized topic' do
-        topic_query.list_new_in_category(category).topics.should == [topic_in_cat, topic_category]
+        expect(topic_query.list_new_in_category(category).topics).to eq([topic_in_cat, topic_category])
       end
     end
   end
@@ -265,7 +265,7 @@ describe TopicQuery do
 
     context 'with no data' do
       it "has no unread topics" do
-        topic_query.list_unread.topics.should be_blank
+        expect(topic_query.list_unread.topics).to be_blank
       end
     end
 
@@ -280,7 +280,7 @@ describe TopicQuery do
 
       context 'list_unread' do
         it 'contains no topics' do
-          topic_query.list_unread.topics.should == []
+          expect(topic_query.list_unread.topics).to eq([])
         end
       end
 
@@ -291,13 +291,13 @@ describe TopicQuery do
         end
 
         it 'only contains the partially read topic' do
-          topic_query.list_unread.topics.should == [partially_read]
+          expect(topic_query.list_unread.topics).to eq([partially_read])
         end
       end
 
       context 'list_read' do
         it 'contain both topics ' do
-          topic_query.list_read.topics.should =~ [fully_read, partially_read]
+          expect(topic_query.list_read.topics).to match_array([fully_read, partially_read])
         end
       end
     end
@@ -308,7 +308,7 @@ describe TopicQuery do
 
     context 'without a new topic' do
       it "has no new topics" do
-        topic_query.list_new.topics.should be_blank
+        expect(topic_query.list_new.topics).to be_blank
       end
     end
 
@@ -318,7 +318,7 @@ describe TopicQuery do
 
 
       it "contains the new topic" do
-        topics.should == [new_topic]
+        expect(topics).to eq([new_topic])
       end
 
       it "contains no new topics for a user that has missed the window" do
@@ -326,7 +326,7 @@ describe TopicQuery do
         user.save
         new_topic.created_at = 10.minutes.ago
         new_topic.save
-        topics.should == []
+        expect(topics).to eq([])
       end
 
       context "muted topics" do
@@ -335,7 +335,7 @@ describe TopicQuery do
         end
 
         it "returns an empty set" do
-          topics.should be_blank
+          expect(topics).to be_blank
         end
 
         context 'un-muted' do
@@ -344,7 +344,7 @@ describe TopicQuery do
           end
 
           it "returns the topic again" do
-            topics.should == [new_topic]
+            expect(topics).to eq([new_topic])
           end
         end
       end
@@ -356,14 +356,14 @@ describe TopicQuery do
     let(:topics) { topic_query.list_posted.topics }
 
     it "returns blank when there are no posted topics" do
-      topics.should be_blank
+      expect(topics).to be_blank
     end
 
     context 'created topics' do
       let!(:created_topic) { create_post(user: user).topic }
 
       it "includes the created topic" do
-        topics.include?(created_topic).should == true
+        expect(topics.include?(created_topic)).to eq(true)
       end
     end
 
@@ -372,7 +372,7 @@ describe TopicQuery do
       let!(:your_post) { create_post(user: user, topic: other_users_topic )}
 
       it "includes the posted topic" do
-        topics.include?(other_users_topic).should == true
+        expect(topics.include?(other_users_topic)).to eq(true)
       end
     end
 
@@ -380,7 +380,7 @@ describe TopicQuery do
       let(:other_users_topic) { create_post(user: creator).topic }
 
       it "does not include the topic" do
-        topics.should be_blank
+        expect(topics).to be_blank
       end
 
       context "but interacted with" do
@@ -388,19 +388,19 @@ describe TopicQuery do
         it "is not included if read" do
           TopicUser.update_last_read(user, other_users_topic.id, 0, 0)
 
-          topics.should be_blank
+          expect(topics).to be_blank
         end
 
         it "is not included if muted" do
           other_users_topic.notify_muted!(user)
 
-          topics.should be_blank
+          expect(topics).to be_blank
         end
 
         it "is not included if tracking" do
           other_users_topic.notify_tracking!(user)
 
-          topics.should be_blank
+          expect(topics).to be_blank
         end
       end
     end
@@ -413,7 +413,7 @@ describe TopicQuery do
       let!(:new_topic) { Fabricate(:post, user: creator).topic }
 
       it "should return the new topic" do
-        TopicQuery.new.list_suggested_for(topic).topics.should == [new_topic]
+        expect(TopicQuery.new.list_suggested_for(topic).topics).to eq([new_topic])
       end
     end
 
@@ -425,7 +425,7 @@ describe TopicQuery do
       let!(:invisible_topic) { Fabricate(:topic, user: creator, visible: false) }
 
       it "should omit the closed/archived/invisbiel topics from suggested" do
-        TopicQuery.new.list_suggested_for(topic).topics.should == [regular_topic]
+        expect(TopicQuery.new.list_suggested_for(topic).topics).to eq([regular_topic])
       end
     end
 
@@ -435,7 +435,7 @@ describe TopicQuery do
       let(:suggested_topics) { topic_query.list_suggested_for(topic).topics.map{|t| t.id} }
 
       it "should return empty results when there is nothing to find" do
-        suggested_topics.should be_blank
+        expect(suggested_topics).to be_blank
       end
 
       context 'with some existing topics' do
@@ -463,24 +463,24 @@ describe TopicQuery do
 
         it "won't return new or fully read if there are enough partially read topics" do
           SiteSetting.stubs(:suggested_topics).returns(1)
-          suggested_topics.should == [partially_read.id]
+          expect(suggested_topics).to eq([partially_read.id])
         end
 
         it "won't return fully read if there are enough partially read topics and new topics" do
           SiteSetting.stubs(:suggested_topics).returns(4)
-          suggested_topics[0].should == partially_read.id
-          suggested_topics[1,3].should include(new_topic.id)
-          suggested_topics[1,3].should include(closed_topic.id)
-          suggested_topics[1,3].should include(archived_topic.id)
+          expect(suggested_topics[0]).to eq(partially_read.id)
+          expect(suggested_topics[1,3]).to include(new_topic.id)
+          expect(suggested_topics[1,3]).to include(closed_topic.id)
+          expect(suggested_topics[1,3]).to include(archived_topic.id)
         end
 
         it "returns unread, then new, then random" do
           SiteSetting.stubs(:suggested_topics).returns(7)
-          suggested_topics[0].should == partially_read.id
-          suggested_topics[1,3].should include(new_topic.id)
-          suggested_topics[1,3].should include(closed_topic.id)
-          suggested_topics[1,3].should include(archived_topic.id)
-          suggested_topics[4].should == fully_read.id
+          expect(suggested_topics[0]).to eq(partially_read.id)
+          expect(suggested_topics[1,3]).to include(new_topic.id)
+          expect(suggested_topics[1,3]).to include(closed_topic.id)
+          expect(suggested_topics[1,3]).to include(archived_topic.id)
+          expect(suggested_topics[4]).to eq(fully_read.id)
           # random doesn't include closed and archived
         end