Fix the test failures

spec/models/track_spec.rb

@@ -75,32 +75,32 @@ describe Track do
       context 'is valid' do
         it 'when the track\'s dates are between the conference\'s dates' do
           track = build(:track, start_date: @conference.start_date, end_date: @conference.end_date, program: @conference.program)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
       end
 
       context 'is invalid' do
         it 'when the track\'s start date is before the conference\'s start date' do
           track = build(:track, start_date: 2.days.ago, end_date: Date.tomorrow, program: @conference.program)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:start_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
         end
 
         it 'when the track\'s start date is after the conference\'s end date' do
           track = build(:track, start_date: 3.days.from_now, end_date: 4.days.from_now, program: @conference.program)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:start_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
         end
 
         it 'when the track\'s end date is before the conference\'s start date' do
           track = build(:track, start_date: 3.days.ago, end_date: 2.days.ago, program: @conference.program)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:end_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
         end
 
         it 'when the track\'s end date is after the conference\'s end date' do
           track = build(:track, start_date: Date.today, end_date: 3.days.from_now, program: @conference.program)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:end_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
         end
       end
@@ -114,14 +114,14 @@ describe Track do
       context 'is valid' do
         it 'when the track\'s start date is before its end date' do
           track = build(:track, start_date: Date.today, end_date: Date.tomorrow, program: @conference.program)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
       end
 
       context 'is invalid' do
         it 'when the track\'s start date is after it\'s end date' do
           track = build(:track, start_date: 1.day.from_now, end_date: 1.day.ago)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:start_date]).to eq ['can\'t be after the end date']
         end
       end
@@ -137,7 +137,7 @@ describe Track do
         it 'when the track\'s room belongs to the venue of the conference' do
           room = create(:room, venue: @conference.venue)
           track = build(:track, :self_organized, state: 'accepted', program: @conference.program, room: room)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
       end
 
@@ -147,7 +147,7 @@ describe Track do
           other_conference.venue = create(:venue)
           room = create(:room, venue: other_conference.venue)
           track = build(:track, :self_organized, state: 'accepted', program: @conference.program, room: room)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:room]).to eq ['must be a room of The venue']
         end
       end
@@ -165,19 +165,19 @@ describe Track do
           other_room = create(:room, venue: @conference.venue)
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: other_room, start_date: Date.current, end_date: Date.current)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
 
         it 'when it ends before the other tracks in the same room' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current - 1.day)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
 
         it 'when it starts after the other tracks in the same room' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 1.day)
-          expect(track.valid?).to eq true
+          expect(track.valid?).to be true
         end
       end
 
@@ -185,35 +185,35 @@ describe Track do
         it 'when it starts and/or ends with another track in the same room' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
         end
 
         it 'when it starts before another track and ends after the other starts and before it ends' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current + 1.day)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
         end
 
         it 'when it starts after another track and before it ends and ends after the other' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 3.days)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
         end
 
         it 'when it starts after another track and ends before the other' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 1.day)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
         end
 
         it 'when it starts before another track and ends after the other' do
           create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
           track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current + 1.day)
-          expect(track.valid?).to eq false
+          expect(track.valid?).to be false
           expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
         end
       end
@@ -229,7 +229,7 @@ describe Track do
       context 'includes' do
         it 'when track is accepted' do
           accepted_track = create(:track, state: 'accepted', program: @program)
-          expect(@program.tracks.accepted.include?(accepted_track)).to eq true
+          expect(@program.tracks.accepted.include?(accepted_track)).to be true
         end
       end
 
@@ -237,7 +237,7 @@ describe Track do
         %w[new to_accept confirmed to_reject rejected canceled withdrawn].each do |state|
           it "when track is #{state.humanize}" do
             not_accepted_track = create(:track, state: state, program: @program)
-            expect(@program.tracks.accepted.include?(not_accepted_track)).to eq false
+            expect(@program.tracks.accepted.include?(not_accepted_track)).to be false
           end
         end
       end
@@ -251,7 +251,7 @@ describe Track do
       context 'includes' do
         it 'tracks with state \'confirmed\'' do
           confirmed_track = create(:track, state: 'confirmed', program: @program)
-          expect(@program.tracks.confirmed.include?(confirmed_track)).to eq true
+          expect(@program.tracks.confirmed.include?(confirmed_track)).to be true
         end
       end
 
@@ -259,7 +259,7 @@ describe Track do
         %w[new to_accept accepted to_reject rejected canceled withdrawn].each do |state|
           it "tracks with state '#{state}'" do
             unconfirmed_track = create(:track, state: state, program: @program)
-            expect(@program.tracks.confirmed.include?(unconfirmed_track)).to eq false
+            expect(@program.tracks.confirmed.include?(unconfirmed_track)).to be false
           end
         end
       end
@@ -273,11 +273,11 @@ describe Track do
       end
 
       it 'include tracks with the cfp_active flag enabled' do
-        expect(@program.tracks.cfp_active.include?(@cfp_active_track)).to eq true
+        expect(@program.tracks.cfp_active.include?(@cfp_active_track)).to be true
       end
 
       it 'excludes tracks with the cfp_active flag disabled' do
-        expect(@program.tracks.cfp_active.include?(@non_cfp_active_track)).to eq false
+        expect(@program.tracks.cfp_active.include?(@non_cfp_active_track)).to be false
       end
     end
 
@@ -291,11 +291,11 @@ describe Track do
       end
 
       it 'includes self-organized tracks' do
-        expect(@program.tracks.self_organized.include?(self_organized_track)).to eq true
+        expect(@program.tracks.self_organized.include?(self_organized_track)).to be true
       end
 
       it 'excludes regular tracks' do
-        expect(@program.tracks.self_organized.include?(track)).to eq false
+        expect(@program.tracks.self_organized.include?(track)).to be false
       end
     end
   end
@@ -303,12 +303,12 @@ describe Track do
   describe '#self_organized?' do
     it 'returns true when it has a submitter' do
       expect(self_organized_track.submitter).to be_a User
-      expect(self_organized_track.self_organized?).to eq true
+      expect(self_organized_track.self_organized?).to be true
     end
 
     it 'returns false when it doesn\'t have a submitter' do
-      expect(track.submitter).to eq nil
-      expect(track.self_organized?).to eq false
+      expect(track.submitter).to be_nil
+      expect(track.self_organized?).to be false
     end
   end
 
@@ -346,17 +346,17 @@ describe Track do
     end
 
     it 'gives the role of the track organizer to the submitter of the track' do
-      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq false
+      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to be false
       self_organized_track.assign_role_to_submitter
-      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq true
+      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to be true
     end
 
     it 'is executed when the track is confirmed' do
       self_organized_track.state = 'accepted'
       self_organized_track.save!
-      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq false
+      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to be false
       self_organized_track.confirm
-      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq true
+      expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to be true
     end
   end
 
@@ -373,23 +373,23 @@ describe Track do
     end
 
     it 'revokes the role of the track organizer' do
-      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq true
+      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to be true
       self_organized_track.revoke_role_and_cleanup
       @a_track_organizer.reload
-      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
+      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to be false
     end
 
     it 'destroys the track\'s schedules' do
       expect(Schedule.find(@schedule_of_self_organized_track.id)).to eq @schedule_of_self_organized_track
       self_organized_track.revoke_role_and_cleanup
-      expect(Schedule.find_by(id: @schedule_of_self_organized_track.id)).to eq nil
+      expect(Schedule.find_by(id: @schedule_of_self_organized_track.id)).to be_nil
     end
 
     it 'removes the track from the events that have it set' do
       expect(@event_of_self_organized_track.track).to eq self_organized_track
       self_organized_track.revoke_role_and_cleanup
       @event_of_self_organized_track.reload
-      expect(@event_of_self_organized_track.track).to eq nil
+      expect(@event_of_self_organized_track.track).to be_nil
     end
 
     it 'sets the state of the track\'s events to new' do
@@ -404,17 +404,17 @@ describe Track do
       self_organized_track.save!
       self_organized_track.cancel
       @a_track_organizer.reload
-      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
+      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to be false
       @event_of_self_organized_track.reload
-      expect(@event_of_self_organized_track.track).to eq nil
+      expect(@event_of_self_organized_track.track).to be_nil
     end
 
     it 'is executed when the track is withdrawn' do
       self_organized_track.withdraw
       @a_track_organizer.reload
-      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
+      expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to be false
       @event_of_self_organized_track.reload
-      expect(@event_of_self_organized_track.track).to eq nil
+      expect(@event_of_self_organized_track.track).to be_nil
     end
   end
 
@@ -423,7 +423,7 @@ describe Track do
       it 'when the state is "accepted"' do
         self_organized_track.state = 'accepted'
         self_organized_track.save!
-        expect(self_organized_track.accepted?).to eq true
+        expect(self_organized_track.accepted?).to be true
       end
     end
 
@@ -432,7 +432,7 @@ describe Track do
         it "when the state is \"#{state}\"" do
           self_organized_track.state = state
           self_organized_track.save!
-          expect(self_organized_track.accepted?).to eq false
+          expect(self_organized_track.accepted?).to be false
         end
       end
     end
@@ -443,7 +443,7 @@ describe Track do
       it 'when the state is "confirmed"' do
         self_organized_track.state = 'confirmed'
         self_organized_track.save!
-        expect(self_organized_track.confirmed?).to eq true
+        expect(self_organized_track.confirmed?).to be true
       end
     end
 
@@ -452,7 +452,7 @@ describe Track do
         it "when the state is \"#{state}\"" do
           self_organized_track.state = state
           self_organized_track.save!
-          expect(self_organized_track.confirmed?).to eq false
+          expect(self_organized_track.confirmed?).to be false
         end
       end
     end
@@ -472,7 +472,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(false)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq true }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be true }
         end
 
         context 'accepted? returns false and confirmed? returns true' do
@@ -481,7 +481,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(true)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq true }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be true }
         end
       end
     end
@@ -498,7 +498,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(false)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be false }
         end
       end
 
@@ -513,7 +513,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(false)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be false }
         end
 
         context 'accepted? returns true and confirmed? returns false' do
@@ -522,7 +522,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(false)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be false }
         end
 
         context 'accepted? returns false and confirmed? returns true' do
@@ -531,7 +531,7 @@ describe Track do
             allow(track).to receive(:confirmed?).and_return(true)
           end
 
-          it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
+          it { expect(track.self_organized_and_accepted_or_confirmed?).to be false }
         end
       end
     end
@@ -539,13 +539,13 @@ describe Track do
 
   describe '#create_organizer_role' do
     it 'creates the role of the track organizer' do
-      expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to eq nil
+      expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to be_nil
       self_organized_track.send(:create_organizer_role)
       expect(Role.find_by(name: 'track_organizer', resource: self_organized_track).description).to eq 'For the organizers of the Track'
     end
 
     it 'is executed when the track is accepted' do
-      expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to eq nil
+      expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to be_nil
       self_organized_track.accept
       expect(Role.find_by(name: 'track_organizer', resource: self_organized_track).description).to eq 'For the organizers of the Track'
     end