FEATURE: remove the timecop gem

We should only have one way of mocking time, misuse of timecop
was causing build stability issues

spec/models/given_daily_like_spec.rb

@@ -21,28 +21,27 @@ describe GivenDailyLike do
     it 'can be incremented and decremented' do
       SiteSetting.max_likes_per_day = 2
 
-      Timecop.freeze(Date.today) do
-        dt = Date.today
+      dt = Date.today
+      freeze_time dt
 
-        expect(value_for(user.id, dt)).to eq(0)
-        expect(limit_reached_for(user.id, dt)).to eq(false)
+      expect(value_for(user.id, dt)).to eq(0)
+      expect(limit_reached_for(user.id, dt)).to eq(false)
 
-        GivenDailyLike.increment_for(user.id)
-        expect(value_for(user.id, dt)).to eq(1)
-        expect(limit_reached_for(user.id, dt)).to eq(false)
+      GivenDailyLike.increment_for(user.id)
+      expect(value_for(user.id, dt)).to eq(1)
+      expect(limit_reached_for(user.id, dt)).to eq(false)
 
-        GivenDailyLike.increment_for(user.id)
-        expect(value_for(user.id, dt)).to eq(2)
-        expect(limit_reached_for(user.id, dt)).to eq(true)
+      GivenDailyLike.increment_for(user.id)
+      expect(value_for(user.id, dt)).to eq(2)
+      expect(limit_reached_for(user.id, dt)).to eq(true)
 
-        GivenDailyLike.decrement_for(user.id)
-        expect(value_for(user.id, dt)).to eq(1)
-        expect(limit_reached_for(user.id, dt)).to eq(false)
+      GivenDailyLike.decrement_for(user.id)
+      expect(value_for(user.id, dt)).to eq(1)
+      expect(limit_reached_for(user.id, dt)).to eq(false)
 
-        GivenDailyLike.decrement_for(user.id)
-        expect(value_for(user.id, dt)).to eq(0)
-        expect(limit_reached_for(user.id, dt)).to eq(false)
-      end
+      GivenDailyLike.decrement_for(user.id)
+      expect(value_for(user.id, dt)).to eq(0)
+      expect(limit_reached_for(user.id, dt)).to eq(false)
     end
 
   end

spec/models/group_spec.rb

@@ -100,15 +100,15 @@ describe Group do
   end
 
   def real_admins
-    Group[:admins].user_ids - [-1]
+    Group[:admins].user_ids.reject{|id| id < 0}
   end
 
   def real_moderators
-    Group[:moderators].user_ids - [-1]
+    Group[:moderators].user_ids.reject{|id| id < 0}
   end
 
   def real_staff
-    Group[:staff].user_ids - [-1]
+    Group[:staff].user_ids.reject{|id| id < 0}
   end
 
   it "Correctly handles primary groups" do
@@ -307,11 +307,11 @@ describe Group do
     user2 = Fabricate(:coding_horror)
     user2.change_trust_level!(TrustLevel[3])
 
-    expect(Group[:trust_level_2].user_ids.sort).to eq [-1, user.id, user2.id].sort
+    expect(Group[:trust_level_2].user_ids.sort.reject{|id| id < -1}).to eq [-1, user.id, user2.id].sort
   end
 
   it "Correctly updates all automatic groups upon request" do
-    Fabricate(:admin)
+    admin = Fabricate(:admin)
     user = Fabricate(:user)
     user.change_trust_level!(TrustLevel[2])
 
@@ -323,22 +323,22 @@ describe Group do
     expect(groups.count).to eq Group::AUTO_GROUPS.count
 
     g = groups.find{|grp| grp.id == Group::AUTO_GROUPS[:admins]}
-    expect(g.users.count).to eq 2
-    expect(g.user_count).to eq 2
+    expect(g.users.count).to eq(g.user_count)
+    expect(g.users.pluck(:id).sort.reject{|id| id < -1}).to eq([-1, admin.id])
 
     g = groups.find{|grp| grp.id == Group::AUTO_GROUPS[:staff]}
-    expect(g.users.count).to eq 2
-    expect(g.user_count).to eq 2
+    expect(g.users.count).to eq (g.user_count)
+    expect(g.users.pluck(:id).sort.reject{|id| id < -1}).to eq([-1, admin.id])
 
     g = groups.find{|grp| grp.id == Group::AUTO_GROUPS[:trust_level_1]}
     # admin, system and user
-    expect(g.users.count).to eq 3
-    expect(g.user_count).to eq 3
+    expect(g.users.count).to eq g.user_count
+    expect(g.users.where('users.id > -2').count).to eq 3
 
     g = groups.find{|grp| grp.id == Group::AUTO_GROUPS[:trust_level_2]}
     # system and user
-    expect(g.users.count).to eq 2
-    expect(g.user_count).to eq 2
+    expect(g.users.count).to eq g.user_count
+    expect(g.users.where('users.id > -2').count).to eq 2
 
   end
 

spec/models/post_action_spec.rb

@@ -178,24 +178,23 @@ describe PostAction do
   describe "update_counters" do
 
     it "properly updates topic counters" do
-      Timecop.freeze(Date.today) do
-        # we need this to test it
-        TopicUser.change(codinghorror, post.topic, posted: true)
+      freeze_time Date.today
+      # we need this to test it
+      TopicUser.change(codinghorror, post.topic, posted: true)
 
-        expect(value_for(moderator.id, Date.today)).to eq(0)
+      expect(value_for(moderator.id, Date.today)).to eq(0)
 
-        PostAction.act(moderator, post, PostActionType.types[:like])
-        PostAction.act(codinghorror, second_post, PostActionType.types[:like])
+      PostAction.act(moderator, post, PostActionType.types[:like])
+      PostAction.act(codinghorror, second_post, PostActionType.types[:like])
 
-        post.topic.reload
-        expect(post.topic.like_count).to eq(2)
+      post.topic.reload
+      expect(post.topic.like_count).to eq(2)
 
-        expect(value_for(moderator.id, Date.today)).to eq(1)
+      expect(value_for(moderator.id, Date.today)).to eq(1)
 
-        tu = TopicUser.get(post.topic, codinghorror)
-        expect(tu.liked).to be true
-        expect(tu.bookmarked).to be false
-      end
+      tu = TopicUser.get(post.topic, codinghorror)
+      expect(tu.liked).to be true
+      expect(tu.bookmarked).to be false
     end
 
   end
@@ -249,33 +248,33 @@ describe PostAction do
     end
 
     it 'should increase the `like_count` and `like_score` when a user likes something' do
-      Timecop.freeze(Date.today) do
-        PostAction.act(codinghorror, post, PostActionType.types[:like])
-        post.reload
-        expect(post.like_count).to eq(1)
-        expect(post.like_score).to eq(1)
-        post.topic.reload
-        expect(post.topic.like_count).to eq(1)
-        expect(value_for(codinghorror.id, Date.today)).to eq(1)
+      freeze_time Date.today
 
-        # When a staff member likes it
-        PostAction.act(moderator, post, PostActionType.types[:like])
-        post.reload
-        expect(post.like_count).to eq(2)
-        expect(post.like_score).to eq(4)
+      PostAction.act(codinghorror, post, PostActionType.types[:like])
+      post.reload
+      expect(post.like_count).to eq(1)
+      expect(post.like_score).to eq(1)
+      post.topic.reload
+      expect(post.topic.like_count).to eq(1)
+      expect(value_for(codinghorror.id, Date.today)).to eq(1)
 
-        # Removing likes
-        PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
-        post.reload
-        expect(post.like_count).to eq(1)
-        expect(post.like_score).to eq(3)
-        expect(value_for(codinghorror.id, Date.today)).to eq(0)
+      # When a staff member likes it
+      PostAction.act(moderator, post, PostActionType.types[:like])
+      post.reload
+      expect(post.like_count).to eq(2)
+      expect(post.like_score).to eq(4)
 
-        PostAction.remove_act(moderator, post, PostActionType.types[:like])
-        post.reload
-        expect(post.like_count).to eq(0)
-        expect(post.like_score).to eq(0)
-      end
+      # Removing likes
+      PostAction.remove_act(codinghorror, post, PostActionType.types[:like])
+      post.reload
+      expect(post.like_count).to eq(1)
+      expect(post.like_score).to eq(3)
+      expect(value_for(codinghorror.id, Date.today)).to eq(0)
+
+      PostAction.remove_act(moderator, post, PostActionType.types[:like])
+      post.reload
+      expect(post.like_count).to eq(0)
+      expect(post.like_score).to eq(0)
     end
   end
 

spec/models/report_spec.rb

@@ -40,7 +40,7 @@ describe Report do
 
       context "with #{pluralized}" do
         before(:each) do
-          Timecop.freeze
+          freeze_time
           fabricator = case arg
           when :signup
             :user
@@ -57,7 +57,6 @@ describe Report do
           Fabricate(fabricator, created_at: 30.days.ago)
           Fabricate(fabricator, created_at: 35.days.ago)
         end
-        after(:each) { Timecop.return }
 
         context 'returns a report with data'
           it "returns today's data" do
@@ -87,15 +86,13 @@ describe Report do
 
       context "with #{request_type}" do
         before(:each) do
-          Timecop.freeze
+          freeze_time
           ApplicationRequest.create(date: 35.days.ago.to_time, req_type: ApplicationRequest.req_types[request_type.to_s], count: 35)
           ApplicationRequest.create(date: 7.days.ago.to_time, req_type: ApplicationRequest.req_types[request_type.to_s], count: 8)
           ApplicationRequest.create(date: Date.today.to_time, req_type: ApplicationRequest.req_types[request_type.to_s], count: 1)
           ApplicationRequest.create(date: 1.day.ago.to_time, req_type: ApplicationRequest.req_types[request_type.to_s], count: 2)
           ApplicationRequest.create(date: 2.days.ago.to_time, req_type: ApplicationRequest.req_types[request_type.to_s], count: 3)
         end
-        after(:each) { Timecop.return }
-
 
         context 'returns a report with data' do
           it "returns expected number of recoords" do

spec/models/screened_email_spec.rb

@@ -78,7 +78,7 @@ describe ScreenedEmail do
 
     shared_examples "when a ScreenedEmail record matches" do
       it "updates statistics" do
-        Timecop.freeze(Time.zone.now) do
+        freeze_time(Time.zone.now) do
           expect { subject }.to change { screened_email.reload.match_count }.by(1)
           expect(screened_email.last_match_at).to be_within_one_second_of(Time.zone.now)
         end

spec/models/search_log_spec.rb

@@ -26,62 +26,59 @@ RSpec.describe SearchLog, type: :model do
 
     context "when anonymous" do
       it "logs and updates the search" do
-        Timecop.freeze do
-          action, log_id = SearchLog.log(
-            term: 'jabba',
-            search_type: :header,
-            ip_address: '192.168.0.33'
-          )
-          expect(action).to eq(:created)
-          log = SearchLog.find(log_id)
-          expect(log.term).to eq('jabba')
-          expect(log.search_type).to eq(SearchLog.search_types[:header])
-          expect(log.ip_address).to eq('192.168.0.33')
+        freeze_time
+        action, log_id = SearchLog.log(
+          term: 'jabba',
+          search_type: :header,
+          ip_address: '192.168.0.33'
+        )
+        expect(action).to eq(:created)
+        log = SearchLog.find(log_id)
+        expect(log.term).to eq('jabba')
+        expect(log.search_type).to eq(SearchLog.search_types[:header])
+        expect(log.ip_address).to eq('192.168.0.33')
 
-          action, updated_log_id = SearchLog.log(
-            term: 'jabba the hut',
-            search_type: :header,
-            ip_address: '192.168.0.33'
-          )
-          expect(action).to eq(:updated)
-          expect(updated_log_id).to eq(log_id)
-        end
+        action, updated_log_id = SearchLog.log(
+          term: 'jabba the hut',
+          search_type: :header,
+          ip_address: '192.168.0.33'
+        )
+        expect(action).to eq(:updated)
+        expect(updated_log_id).to eq(log_id)
       end
 
       it "creates a new search with a different prefix" do
-        Timecop.freeze do
-          action, _ = SearchLog.log(
-            term: 'darth',
-            search_type: :header,
-            ip_address: '127.0.0.1'
-          )
-          expect(action).to eq(:created)
+        freeze_time
+        action, _ = SearchLog.log(
+          term: 'darth',
+          search_type: :header,
+          ip_address: '127.0.0.1'
+        )
+        expect(action).to eq(:created)
 
-          action, _ = SearchLog.log(
-            term: 'anakin',
-            search_type: :header,
-            ip_address: '127.0.0.1'
-          )
-          expect(action).to eq(:created)
-        end
+        action, _ = SearchLog.log(
+          term: 'anakin',
+          search_type: :header,
+          ip_address: '127.0.0.1'
+        )
+        expect(action).to eq(:created)
       end
 
       it "creates a new search with a different ip" do
-        Timecop.freeze do
-          action, _ = SearchLog.log(
-            term: 'darth',
-            search_type: :header,
-            ip_address: '127.0.0.1'
-          )
-          expect(action).to eq(:created)
+        freeze_time
+        action, _ = SearchLog.log(
+          term: 'darth',
+          search_type: :header,
+          ip_address: '127.0.0.1'
+        )
+        expect(action).to eq(:created)
 
-          action, _ = SearchLog.log(
-            term: 'darth',
-            search_type: :header,
-            ip_address: '127.0.0.2'
-          )
-          expect(action).to eq(:created)
-        end
+        action, _ = SearchLog.log(
+          term: 'darth',
+          search_type: :header,
+          ip_address: '127.0.0.2'
+        )
+        expect(action).to eq(:created)
       end
     end
 
@@ -89,71 +86,71 @@ RSpec.describe SearchLog, type: :model do
       let(:user) { Fabricate(:user) }
 
       it "logs and updates the search" do
-        Timecop.freeze do
-          action, log_id = SearchLog.log(
-            term: 'hello',
-            search_type: :full_page,
-            ip_address: '192.168.0.1',
-            user_id: user.id
-          )
-          expect(action).to eq(:created)
-          log = SearchLog.find(log_id)
-          expect(log.term).to eq('hello')
-          expect(log.search_type).to eq(SearchLog.search_types[:full_page])
-          expect(log.ip_address).to eq('192.168.0.1')
-          expect(log.user_id).to eq(user.id)
+        freeze_time
+        action, log_id = SearchLog.log(
+          term: 'hello',
+          search_type: :full_page,
+          ip_address: '192.168.0.1',
+          user_id: user.id
+        )
+        expect(action).to eq(:created)
+        log = SearchLog.find(log_id)
+        expect(log.term).to eq('hello')
+        expect(log.search_type).to eq(SearchLog.search_types[:full_page])
+        expect(log.ip_address).to eq('192.168.0.1')
+        expect(log.user_id).to eq(user.id)
 
-          action, updated_log_id = SearchLog.log(
-            term: 'hello dolly',
-            search_type: :header,
-            ip_address: '192.168.0.33',
-            user_id: user.id
-          )
-          expect(action).to eq(:updated)
-          expect(updated_log_id).to eq(log_id)
-        end
+        action, updated_log_id = SearchLog.log(
+          term: 'hello dolly',
+          search_type: :header,
+          ip_address: '192.168.0.33',
+          user_id: user.id
+        )
+        expect(action).to eq(:updated)
+        expect(updated_log_id).to eq(log_id)
       end
 
       it "logs again if time has passed" do
-        Timecop.freeze(10.minutes.ago) do
-          action, _ = SearchLog.log(
-            term: 'hello',
-            search_type: :full_page,
-            ip_address: '192.168.0.1',
-            user_id: user.id
-          )
-          expect(action).to eq(:created)
-        end
+        freeze_time(10.minutes.ago)
 
-        Timecop.freeze do
-          action, _ = SearchLog.log(
-            term: 'hello',
-            search_type: :full_page,
-            ip_address: '192.168.0.1',
-            user_id: user.id
-          )
-          expect(action).to eq(:created)
-        end
+        action, _ = SearchLog.log(
+          term: 'hello',
+          search_type: :full_page,
+          ip_address: '192.168.0.1',
+          user_id: user.id
+        )
+        expect(action).to eq(:created)
+
+        freeze_time(10.minutes.from_now)
+
+        action, _ = SearchLog.log(
+          term: 'hello',
+          search_type: :full_page,
+          ip_address: '192.168.0.1',
+          user_id: user.id
+        )
+
+        expect(action).to eq(:created)
       end
 
       it "logs again with a different user" do
-        Timecop.freeze do
-          action, _ = SearchLog.log(
-            term: 'hello',
-            search_type: :full_page,
-            ip_address: '192.168.0.1',
-            user_id: user.id
-          )
-          expect(action).to eq(:created)
+        freeze_time
 
-          action, _ = SearchLog.log(
-            term: 'hello dolly',
-            search_type: :full_page,
-            ip_address: '192.168.0.1',
-            user_id: Fabricate(:user).id
-          )
-          expect(action).to eq(:created)
-        end
+        action, _ = SearchLog.log(
+          term: 'hello',
+          search_type: :full_page,
+          ip_address: '192.168.0.1',
+          user_id: user.id
+        )
+        expect(action).to eq(:created)
+
+        action, _ = SearchLog.log(
+          term: 'hello dolly',
+          search_type: :full_page,
+          ip_address: '192.168.0.1',
+          user_id: Fabricate(:user).id
+        )
+        expect(action).to eq(:created)
       end
 
     end

spec/models/site_setting_spec.rb

@@ -128,10 +128,6 @@ describe SiteSetting do
       SiteSetting.force_https = true
     end
 
-    after do
-      SiteSetting.force_https = false
-    end
-
     describe '#use_https' do
       it 'should act as a proxy to the new methods' do
         expect(SiteSetting.use_https).to eq(true)

spec/models/topic_converter_spec.rb

@@ -11,7 +11,7 @@ describe TopicConverter do
     context 'success' do
       it "converts private message to regular topic" do
         SiteSetting.allow_uncategorized_topics = true
-        topic = described_class.new(private_message, admin).convert_to_public_topic
+        topic = TopicConverter.new(private_message, admin).convert_to_public_topic
         topic.reload
 
         expect(topic).to be_valid
@@ -26,18 +26,22 @@ describe TopicConverter do
         end
 
         it 'should convert private message into the right category' do
-          topic = described_class.new(private_message, admin).convert_to_public_topic
+          topic = TopicConverter.new(private_message, admin).convert_to_public_topic
           topic.reload
 
           expect(topic).to be_valid
           expect(topic.archetype).to eq("regular")
-          expect(topic.category_id).to eq(category.id)
+
+          first_category = Category.where.not(id: SiteSetting.uncategorized_category_id)
+                                   .where(read_restricted: false).order('id asc').first
+
+          expect(topic.category_id).to eq(first_category.id)
         end
       end
 
       describe 'when a custom category_id is given' do
         it 'should convert private message into the right category' do
-          topic = described_class.new(private_message, admin).convert_to_public_topic(category.id)
+          topic = TopicConverter.new(private_message, admin).convert_to_public_topic(category.id)
 
           expect(topic.reload.category).to eq(category)
         end

spec/models/topic_spec.rb

@@ -1164,68 +1164,60 @@ describe Topic do
     before { Discourse.stubs(:system_user).returns(admin) }
 
     it 'can take a number of hours as an integer' do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], 72, by_user: admin)
-        expect(topic.topic_timers.first.execute_at).to eq(3.days.from_now)
-      end
+      freeze_time now
+
+      topic.set_or_create_timer(TopicTimer.types[:close], 72, by_user: admin)
+      expect(topic.topic_timers.first.execute_at).to eq(3.days.from_now)
     end
 
     it 'can take a number of hours as an integer, with timezone offset' do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], 72, {by_user: admin, timezone_offset: 240})
-        expect(topic.topic_timers.first.execute_at).to eq(3.days.from_now)
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], 72, {by_user: admin, timezone_offset: 240})
+      expect(topic.topic_timers.first.execute_at).to eq(3.days.from_now)
     end
 
     it 'can take a number of hours as a string' do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '18', by_user: admin)
-        expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '18', by_user: admin)
+      expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
     end
 
     it 'can take a number of hours as a string, with timezone offset' do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '18', {by_user: admin, timezone_offset: 240})
-        expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '18', {by_user: admin, timezone_offset: 240})
+      expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
     end
 
     it 'can take a number of hours as a string and can handle based on last post' do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '18', {by_user: admin, based_on_last_post: true})
-        expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '18', {by_user: admin, based_on_last_post: true})
+      expect(topic.topic_timers.first.execute_at).to eq(18.hours.from_now)
     end
 
     it "can take a timestamp for a future time" do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-22 5:00', {by_user: admin})
-        expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,22,5,0))
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-22 5:00', {by_user: admin})
+      expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,22,5,0))
     end
 
     it "can take a timestamp for a future time, with timezone offset" do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-22 5:00', {by_user: admin, timezone_offset: 240})
-        expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,22,9,0))
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-22 5:00', {by_user: admin, timezone_offset: 240})
+      expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,22,9,0))
     end
 
     it "sets a validation error when given a timestamp in the past" do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-19 5:00', {by_user: admin})
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-19 5:00', {by_user: admin})
 
-        expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,19,5,0))
-        expect(topic.topic_timers.first.errors[:execute_at]).to be_present
-      end
+      expect(topic.topic_timers.first.execute_at).to eq(Time.zone.local(2013,11,19,5,0))
+      expect(topic.topic_timers.first.errors[:execute_at]).to be_present
     end
 
     it "can take a timestamp with timezone" do
-      Timecop.freeze(now) do
-        topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-25T01:35:00-08:00', {by_user: admin})
-        expect(topic.topic_timers.first.execute_at).to eq(Time.utc(2013,11,25,9,35))
-      end
+      freeze_time now
+      topic.set_or_create_timer(TopicTimer.types[:close], '2013-11-25T01:35:00-08:00', {by_user: admin})
+      expect(topic.topic_timers.first.execute_at).to eq(Time.utc(2013,11,25,9,35))
     end
 
     it 'sets topic status update user to given user if it is a staff or TL4 user' do
@@ -1267,20 +1259,19 @@ describe Topic do
     end
 
     it 'updates topic status update execute_at if it was already set to close' do
-      Timecop.freeze(now) do
-        closing_topic.set_or_create_timer(TopicTimer.types[:close], 48)
-        expect(closing_topic.reload.public_topic_timer.execute_at).to eq(2.days.from_now)
-      end
+      freeze_time now
+      closing_topic.set_or_create_timer(TopicTimer.types[:close], 48)
+      expect(closing_topic.reload.public_topic_timer.execute_at).to eq(2.days.from_now)
     end
 
     it 'should allow status_type to be updated' do
-      Timecop.freeze do
-        topic_timer = closing_topic.set_or_create_timer(
-          TopicTimer.types[:publish_to_category], 72, by_user: admin
-        )
+      freeze_time
 
-        expect(topic_timer.execute_at).to eq(3.days.from_now)
-      end
+      topic_timer = closing_topic.set_or_create_timer(
+        TopicTimer.types[:publish_to_category], 72, by_user: admin
+      )
+
+      expect(topic_timer.execute_at).to eq(3.days.from_now)
     end
 
     it "does not update topic's topic status created_at it was already set to close" do
@@ -1300,10 +1291,10 @@ describe Topic do
 
         expect(topic.reload.closed).to eq(false)
 
-        Timecop.travel(3.hours.from_now) do
-          TopicTimer.ensure_consistency!
-          expect(topic.reload.closed).to eq(true)
-        end
+        freeze_time 3.hours.from_now
+
+        TopicTimer.ensure_consistency!
+        expect(topic.reload.closed).to eq(true)
       end
     end
 
@@ -1320,14 +1311,14 @@ describe Topic do
       end
 
       it "can update a user's existing record" do
-        Timecop.freeze(now) do
-          reminder
-          expect {
-            topic.set_or_create_timer(TopicTimer.types[:reminder], 11, by_user: admin)
-          }.to_not change { TopicTimer.count }
-          reminder.reload
-          expect(reminder.execute_at).to eq(11.hours.from_now)
-        end
+        freeze_time now
+
+        reminder
+        expect {
+          topic.set_or_create_timer(TopicTimer.types[:reminder], 11, by_user: admin)
+        }.to_not change { TopicTimer.count }
+        reminder.reload
+        expect(reminder.execute_at).to eq(11.hours.from_now)
       end
     end
   end
@@ -1510,16 +1501,15 @@ describe Topic do
 
   describe '#listable_count_per_day' do
     before(:each) do
-      Timecop.freeze
+      freeze_time
+
       Fabricate(:topic)
       Fabricate(:topic, created_at: 1.day.ago)
       Fabricate(:topic, created_at: 1.day.ago)
       Fabricate(:topic, created_at: 2.days.ago)
       Fabricate(:topic, created_at: 4.days.ago)
     end
-    after(:each) do
-      Timecop.return
-    end
+
     let(:listable_topics_count_per_day) { {1.day.ago.to_date => 2, 2.days.ago.to_date => 1, Time.now.utc.to_date => 1 } }
 
     it 'collect closed interval listable topics count' do

spec/models/topic_timer_spec.rb

@@ -113,63 +113,60 @@ RSpec.describe TopicTimer, type: :model do
 
     describe 'when #execute_at value is changed' do
       it 'reschedules the job' do
-        Timecop.freeze do
-          topic_timer
+        freeze_time
+        topic_timer
 
-          Jobs.expects(:cancel_scheduled_job).with(
-            :toggle_topic_closed, topic_timer_id: topic_timer.id
-          )
+        Jobs.expects(:cancel_scheduled_job).with(
+          :toggle_topic_closed, topic_timer_id: topic_timer.id
+        )
 
-          Jobs.expects(:enqueue_at).with(
-            3.days.from_now, :toggle_topic_closed,
-            topic_timer_id: topic_timer.id,
-            state: true
-          )
+        Jobs.expects(:enqueue_at).with(
+          3.days.from_now, :toggle_topic_closed,
+          topic_timer_id: topic_timer.id,
+          state: true
+        )
 
-          topic_timer.update!(execute_at: 3.days.from_now, created_at: Time.zone.now)
-        end
+        topic_timer.update!(execute_at: 3.days.from_now, created_at: Time.zone.now)
       end
 
       describe 'when execute_at is smaller than the current time' do
         it 'should enqueue the job immediately' do
-          Timecop.freeze do
-            topic_timer
+          freeze_time
+          topic_timer
 
-            Jobs.expects(:enqueue_at).with(
-              Time.zone.now, :toggle_topic_closed,
-              topic_timer_id: topic_timer.id,
-              state: true
-            )
+          Jobs.expects(:enqueue_at).with(
+            Time.zone.now, :toggle_topic_closed,
+            topic_timer_id: topic_timer.id,
+            state: true
+          )
 
-            topic_timer.update!(
-              execute_at: Time.zone.now - 1.hour,
-              created_at: Time.zone.now - 2.hour
-            )
-          end
+          topic_timer.update!(
+            execute_at: Time.zone.now - 1.hour,
+            created_at: Time.zone.now - 2.hour
+          )
         end
       end
     end
 
     describe 'when user is changed' do
       it 'should update the job' do
-        Timecop.freeze do
-          topic_timer
+        freeze_time
+        topic_timer
 
-          Jobs.expects(:cancel_scheduled_job).with(
-            :toggle_topic_closed, topic_timer_id: topic_timer.id
-          )
+        Jobs.expects(:cancel_scheduled_job).with(
+          :toggle_topic_closed, topic_timer_id: topic_timer.id
+        )
 
-          admin = Fabricate(:admin)
+        admin = Fabricate(:admin)
 
-          Jobs.expects(:enqueue_at).with(
-            topic_timer.execute_at,
-            :toggle_topic_closed,
-            topic_timer_id: topic_timer.id,
-            state: true
-          )
+        Jobs.expects(:enqueue_at).with(
+          topic_timer.execute_at,
+          :toggle_topic_closed,
+          topic_timer_id: topic_timer.id,
+          state: true
+        )
 
-          topic_timer.update!(user: admin)
-        end
+        topic_timer.update!(user: admin)
       end
     end
 

spec/models/user_spec.rb

@@ -31,14 +31,13 @@ describe User do
   describe '#count_by_signup_date' do
     before(:each) do
       User.destroy_all
-      Timecop.freeze
+      freeze_time
       Fabricate(:user)
       Fabricate(:user, created_at: 1.day.ago)
       Fabricate(:user, created_at: 1.day.ago)
       Fabricate(:user, created_at: 2.days.ago)
       Fabricate(:user, created_at: 4.days.ago)
     end
-    after(:each) { Timecop.return }
     let(:signups_by_day) { {1.day.ago.to_date => 2, 2.days.ago.to_date => 1, Time.now.utc.to_date => 1} }
 
     it 'collect closed interval signups' do
@@ -716,14 +715,10 @@ describe User do
       let!(:date) { Time.zone.now }
 
       before do
-        Timecop.freeze(date)
+        freeze_time date
         user.update_last_seen!
       end
 
-      after do
-        Timecop.return
-      end
-
       it "updates last_seen_at" do
         expect(user.last_seen_at).to be_within_one_second_of(date)
       end
@@ -740,16 +735,12 @@ describe User do
       context "called twice" do
 
         before do
-          Timecop.freeze(date)
+          freeze_time date
           user.update_last_seen!
           user.update_last_seen!
           user.reload
         end
 
-        after do
-          Timecop.return
-        end
-
         it "doesn't increase days_visited twice" do
           expect(user.user_stat.days_visited).to eq(1)
         end
@@ -760,14 +751,10 @@ describe User do
         let!(:future_date) { 3.days.from_now }
 
         before do
-          Timecop.freeze(future_date)
+          freeze_time future_date
           user.update_last_seen!
         end
 
-        after do
-          Timecop.return
-        end
-
         it "should log a second visited_at record when we log an update later" do
           expect(user.user_visits.count).to eq(2)
         end
@@ -1498,7 +1485,7 @@ describe User do
 
   describe '.human_users' do
     it 'should only return users with a positive primary key' do
-      Fabricate(:user, id: -2)
+      Fabricate(:user, id: -1979)
       user = Fabricate(:user)
 
       expect(User.human_users).to eq([user])

spec/models/user_visit_spec.rb

@@ -23,14 +23,13 @@ describe UserVisit do
 
   describe '#by_day' do
     before(:each) do
-      Timecop.freeze
+      freeze_time
       user.user_visits.create(visited_at: Time.zone.now)
       user.user_visits.create(visited_at: 1.day.ago)
       other_user.user_visits.create(visited_at: 1.day.ago)
       user.user_visits.create(visited_at: 2.days.ago)
       user.user_visits.create(visited_at: 4.days.ago)
     end
-    after(:each) { Timecop.return }
     let(:visits_by_day) { {1.day.ago.to_date => 2, 2.days.ago.to_date => 1, Time.zone.now.to_date => 1 } }
 
     it 'collect closed interval visits' do