dgp-schedule_attributes 0.4.0 → 0.5.0

data/spec/schedule_attributes/rule_parser/day_spec.rb

@@ -14,46 +14,46 @@ describe ScheduleAttributes::RuleParser::Day do
     context 'no arguments', args: {} do
       let(:every_day) { [t, t+1.day, t+2.days, t+3.days, t+4.days, t+5.days, t+6.days, t+7.days, t+8.days] }
 
-      it { should == IceCube::Rule.daily }
-      its_occurrences_until(8.days.from_now) { should == every_day }
+      it { is_expected.to eq(IceCube::Rule.daily) }
+      its_occurrences_until(8.days.from_now) { is_expected.to eq(every_day) }
     end
 
     context 'interval argument', args: {interval: 2} do
       let(:every_other_day) { [t, t+2.days, t+4.days, t+6.days, t+8.days] }
 
-      it { should == IceCube::Rule.daily(2) }
-      its_occurrences_until(8.days.from_now) { should == every_other_day }
+      it { is_expected.to eq(IceCube::Rule.daily(2)) }
+      its_occurrences_until(8.days.from_now) { is_expected.to eq(every_other_day) }
     end
 
     context 'end_date argument', args: {end_date: '2014-01-30'} do
       let(:t)           { Time.new(2014,01,30) }
       let(:last_5_days) { [t-4.days, t-3.days, t-2.days, t-1.day, t] }
 
-      it { should == IceCube::Rule.daily.until(t) }
-      its_occurrences_until(Time.new(2014,02,01)) { subject[-5..-1].should == last_5_days }
+      it { is_expected.to eq(IceCube::Rule.daily.until(t)) }
+      its_occurrences_until(Time.new(2014,02,01)) { expect(subject[-5..-1]).to eq last_5_days }
     end
 
     context 'yearly_start_month and yearly_end_month arguments, whole year', args: {yearly_start_month: 1, yearly_end_month: 12} do
-      it { should == IceCube::Rule.daily }
+      it { is_expected.to eq(IceCube::Rule.daily) }
     end
 
     context 'yearly_start_month and yearly_end_month arguments, less than a year', args: {yearly_start_month: 6, yearly_end_month: 8} do
-      it { should == IceCube::Rule.daily.month_of_year(6,7,8) }
+      it { is_expected.to eq(IceCube::Rule.daily.month_of_year(6,7,8)) }
     end
 
     context 'yearly_start_month and yearly_end_month arguments, jump year', args: {yearly_start_month: 11, yearly_end_month: 1} do
-      it { should == IceCube::Rule.daily.month_of_year(11,12,1) }
+      it { is_expected.to eq(IceCube::Rule.daily.month_of_year(11,12,1)) }
     end
 
     context 'yearly_start_month and yearly_end_month arguments, jump year alt', args: {yearly_start_month: 12, yearly_end_month: 2} do
-      it { should == IceCube::Rule.daily.month_of_year(12,1,2) }
+      it { is_expected.to eq(IceCube::Rule.daily.month_of_year(12,1,2)) }
     end
 
     context 'yearly_start_month, yearly_start_month_day, yearly_end_month and yearly_end_month_day arguments', args: {
       yearly_start_month: 3, yearly_start_month_day: 14,
       yearly_end_month:   3, yearly_end_month_day:   17
     } do
-      it { should == IceCube::Rule.daily.month_of_year(3) }
+      it { is_expected.to eq(IceCube::Rule.daily.month_of_year(3)) }
     end
   end
 
@@ -65,48 +65,48 @@ describe ScheduleAttributes::RuleParser::Day do
       yearly_end_month:   3, yearly_end_month_day:   26
     } do
       it "returns exceptions for the leading & trailing days" do
-        should == [
+        is_expected.to eq([
           IceCube::Rule.daily.month_of_year(3).day_of_month(*1..3),
           IceCube::Rule.daily.month_of_year(3).day_of_month(*27..31)
-        ]
+        ])
       end
     end
 
     context 'yearly_start_month and yearly_end_month arguments', args: {yearly_start_month: 3, yearly_end_month: 3} do
       it "has no trailing exceptions" do
-        should == []
+        is_expected.to eq([])
       end
     end
 
     context 'yearly_start_month, yearly_end_month and yearly_end_month_day arguments', args: {yearly_start_month: 3, yearly_end_month: 4, yearly_end_month_day: 25} do
       it "returns exceptions for the trailing days of the last month only" do
-        should == [IceCube::Rule.daily.month_of_year(4).day_of_month(*26..31)]
+        is_expected.to eq([IceCube::Rule.daily.month_of_year(4).day_of_month(*26..31)])
       end
     end
 
     context 'yearly_start_month, yearly_start_month_day and yearly_end_month arguments', args: {yearly_start_month: 3, yearly_start_month_day: 3, yearly_end_month: 4} do
       it "returns exceptions for the leading days of the first month" do
-        should == [
+        is_expected.to eq([
           IceCube::Rule.daily.month_of_year(3).day_of_month(*1..2)
-        ]
+        ])
       end
     end
 
     context 'yearly_start_month, yearly_end_month, yearly_start_month_day and yearly_end_month_day arguments', args: {yearly_start_month: 3, yearly_end_month: 4, yearly_start_month_day: 31, yearly_end_month_day: 1} do
       it "excepts the first 30 days of first month and last 30 days of last month" do
-        should == [
+        is_expected.to eq([
           IceCube::Rule.daily.month_of_year(3).day_of_month(*1..30),
           IceCube::Rule.daily.month_of_year(4).day_of_month(*2..31)
-        ]
+        ])
       end
     end
 
     context 'yearly_start_month, yearly_end_month, yearly_start_month_day and yearly_end_month_day arguments', args: {yearly_start_month: 12, yearly_end_month: 1, yearly_start_month_day: 31, yearly_end_month_day: 1} do
       it "excepts the first 30 days of first month and last 30 days of last month" do
-        should == [
+        is_expected.to eq([
           IceCube::Rule.daily.month_of_year(12).day_of_month(*1..30),
           IceCube::Rule.daily.month_of_year(1).day_of_month(*2..31)
-        ]
+        ])
       end
     end
   end

data/spec/schedule_attributes/rule_parser/month_spec.rb

@@ -18,30 +18,30 @@ describe ScheduleAttributes::RuleParser::Month do
     let(:every_14th) { [n, n >> 1, n >> 2, n >> 3].map(&:to_time) }
 
     context 'no arguments', args: {} do
-      it { should == IceCube::Rule.monthly }
-      its_occurrences_until(3.months.from_now) { should == monthly }
+      it { is_expected.to eq(IceCube::Rule.monthly) }
+      its_occurrences_until(3.months.from_now) { is_expected.to eq(monthly) }
     end
 
     context 'start_date and interval arguments', args: {"start_date" => "2000-03-14", "interval" => "2"} do
-      it { should == IceCube::Rule.monthly(2) }
-      its_occurrences_until(6.months.from_now) { should == bimonthly }
+      it { is_expected.to eq(IceCube::Rule.monthly(2)) }
+      its_occurrences_until(6.months.from_now) { is_expected.to eq(bimonthly) }
     end
 
     context 'ordinal_unit and ordinal_day arguments', args: {"ordinal_unit" => "day", "ordinal_day" => "14"} do
-      it { should == IceCube::Rule.monthly.day_of_month(14) }
-      its_occurrences_until(4.months.from_now) { should == every_14th }
+      it { is_expected.to eq(IceCube::Rule.monthly.day_of_month(14)) }
+      its_occurrences_until(4.months.from_now) { is_expected.to eq(every_14th) }
     end
 
     context 'ordinal_unit, ordinal_week and tuesday arguments', args: {"ordinal_unit" => "week", "ordinal_week" => "2", "tuesday" => "1"} do
-      it { should == IceCube::Rule.monthly.day_of_week(:tuesday => [2]) }
+      it { is_expected.to eq(IceCube::Rule.monthly.day_of_week(:tuesday => [2])) }
     end
 
     context 'ordinal_unit and ordinal_week arguments', args: {"ordinal_unit" => "week", "ordinal_week" => "2"} do
-      it { should == IceCube::Rule.monthly.day_of_week(0=>(w=[2]), 1=>w, 2=>w, 3=>w, 4=>w, 5=>w, 6=>w) }
+      it { is_expected.to eq(IceCube::Rule.monthly.day_of_week(0=>(w=[2]), 1=>w, 2=>w, 3=>w, 4=>w, 5=>w, 6=>w)) }
     end
 
     context 'start_date and end_date arguments', args: {"start_date" => "2000-03-14", "end_date" => "2000-06-14"} do
-      it { should == IceCube::Rule.monthly.until(Time.new(2000,6,14)) }
+      it { is_expected.to eq(IceCube::Rule.monthly.until(Time.new(2000,6,14))) }
     end
   end
 end

data/spec/schedule_attributes/rule_parser/week_spec.rb

@@ -19,18 +19,18 @@ describe ScheduleAttributes::RuleParser::Week do
     subject      { parser.rule }
 
     context 'no arguments', args: {} do
-      it { should == IceCube::Rule.weekly }
-      its_occurrences_until(5.weeks.from_now) { should == weekly }
+      it { is_expected.to eq(IceCube::Rule.weekly) }
+      its_occurrences_until(5.weeks.from_now) { is_expected.to eq(weekly) }
     end
 
     context 'interval argument', args: {"interval" => "2"} do
-      it { should == IceCube::Rule.weekly(2) }
-      its_occurrences_until(5.weeks.from_now) { should == every_2_weeks }
+      it { is_expected.to eq(IceCube::Rule.weekly(2)) }
+      its_occurrences_until(5.weeks.from_now) { is_expected.to eq(every_2_weeks) }
     end
 
     context 'several day name arguments', args: {"monday" => "0", "saturday" => "1", "sunday" => "1"} do
-      it { should == IceCube::Rule.weekly.day(0,6) }
-      its_occurrences_until(Date.today.beginning_of_week+3.weeks) { subject[-4..-1].should == weekends[-4..-1] }
+      it { is_expected.to eq(IceCube::Rule.weekly.day(0,6)) }
+      its_occurrences_until(Date.today.beginning_of_week+3.weeks) { expect(subject[-4..-1]).to eq weekends[-4..-1] }
     end
   end
 end

data/spec/schedule_attributes/rule_parser/year_spec.rb

@@ -17,26 +17,26 @@ describe ScheduleAttributes::RuleParser::Year do
     subject      { parser.rule }
 
     context 'no arguments', args: {} do
-      it { should == IceCube::Rule.yearly }
-      its_occurrences_until(4.years.from_now) { should == every_year }
+      it { is_expected.to eq(IceCube::Rule.yearly) }
+      its_occurrences_until(4.years.from_now) { is_expected.to eq(every_year) }
     end
 
     context 'interval argument', args: {"interval" => "2"} do
-      it { should == IceCube::Rule.yearly(2) }
-      its_occurrences_until(4.years.from_now) { should == every_2nd_year }
+      it { is_expected.to eq(IceCube::Rule.yearly(2)) }
+      its_occurrences_until(4.years.from_now) { is_expected.to eq(every_2nd_year) }
     end
 
     context 'start_date argument', args: {"start_date" => "2000-03-14"} do
-      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14) }
+      it { is_expected.to eq(IceCube::Rule.yearly.month_of_year(3).day_of_month(14)) }
     end
 
     context 'start_date argument alt', args: {"start_date" => "2000-01-30"} do
-      it { should == IceCube::Rule.yearly.month_of_year(1).day_of_month(30) }
+      it { is_expected.to eq(IceCube::Rule.yearly.month_of_year(1).day_of_month(30)) }
     end
 
     context 'start_date and end_date arguments', args: {"start_date" => "2000-03-14", "end_date" => "#{Date.current.year+4}-03-14"} do
-      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14).until(Date.new(Date.current.year+4,3,14).to_time) }
-      its_occurrences_until(10.years.from_now) { should == every_pi_day }
+      it { is_expected.to eq(IceCube::Rule.yearly.month_of_year(3).day_of_month(14).until(Date.new(Date.current.year+4,3,14).to_time)) }
+      its_occurrences_until(10.years.from_now) { is_expected.to eq(every_pi_day) }
     end
 
     context "ignoring yearly_start and end limits", args: {
@@ -46,8 +46,8 @@ describe ScheduleAttributes::RuleParser::Year do
       "yearly_end_month"       => "5",
       "yearly_end_month_day"   => "20"
     } do
-      it { should == IceCube::Rule.yearly.month_of_year(3).day_of_month(14) }
-      its_occurrences_until(Date.new(Date.current.year+4,12,31)) { should == every_pi_day }
+      it { is_expected.to eq(IceCube::Rule.yearly.month_of_year(3).day_of_month(14)) }
+      its_occurrences_until(Date.new(Date.current.year+4,12,31)) { is_expected.to eq(every_pi_day) }
     end
   end
 end

data/spec/schedule_attributes/rule_parser_spec.rb

@@ -11,7 +11,7 @@ describe ScheduleAttributes::RuleParser do
     }. each do |key,parser_class|
 
       it "returns parser for #{key} interval units" do
-        ScheduleAttributes::RuleParser[key].should == parser_class
+        expect(ScheduleAttributes::RuleParser[key]).to eq(parser_class)
       end
     end
   end

data/spec/schedule_attributes/time_helpers_spec.rb

@@ -9,17 +9,17 @@ describe ScheduleAttributes::TimeHelpers do
       before { Time.zone = 'UTC' }
 
       it "returns a time from a date string" do
-        subject.parse_in_zone("2000-12-31").should == Time.zone.parse("2000-12-31")
+        expect(subject.parse_in_zone("2000-12-31")).to eq(Time.zone.parse("2000-12-31"))
       end
 
       it "returns a time from a time" do
         local_offset = "-08:00"
         local_time = Time.new(2000,12,31,0,0,0,local_offset)
-        subject.parse_in_zone(local_time).should == Time.zone.parse("2000-12-31 08:00:00")
+        expect(subject.parse_in_zone(local_time)).to eq(Time.zone.parse("2000-12-31 08:00:00"))
       end
 
       it "returns a time from a date" do
-        subject.parse_in_zone(Date.new(2000,12,31)).should == Time.zone.parse("2000-12-31")
+        expect(subject.parse_in_zone(Date.new(2000,12,31))).to eq(Time.zone.parse("2000-12-31"))
       end
     end
 
@@ -27,11 +27,11 @@ describe ScheduleAttributes::TimeHelpers do
       before { Time.zone = nil }
 
       it "returns a time from a date string" do
-        subject.parse_in_zone("2000-12-31").should == Time.parse("2000-12-31")
+        expect(subject.parse_in_zone("2000-12-31")).to eq(Time.parse("2000-12-31"))
       end
 
       it "returns a time from a time" do
-        subject.parse_in_zone(Time.new(2000,12,31)).should == Time.parse("2000-12-31")
+        expect(subject.parse_in_zone(Time.new(2000,12,31))).to eq(Time.parse("2000-12-31"))
       end
     end
 

data/spec/schedule_attributes_spec.rb

@@ -7,11 +7,11 @@ describe ScheduledModel do
     subject(:schedule) { ScheduledModel.new.schedule }
 
     it "should default to a daily schedule" do
-      schedule.should be_a(IceCube::Schedule)
-      schedule.rtimes.should == []
-      schedule.start_time.should == Date.today.to_time
-      schedule.end_time.should be nil
-      schedule.rrules.should == [IceCube::Rule.daily]
+      expect(schedule).to be_a(IceCube::Schedule)
+      expect(schedule.rtimes).to eq([])
+      expect(schedule.start_time).to eq(Date.today.to_time)
+      expect(schedule.end_time).to be nil
+      expect(schedule.rrules).to eq([IceCube::Rule.daily])
     end
   end
 
@@ -21,80 +21,80 @@ describe ScheduledModel do
       subject(:schedule)    { scheduled_model.schedule }
 
       context args: {repeat: '0', date: '1-1-1985', interval: '5 (ignore this)'} do
-        it { subject.start_time.should == Time.new(1985,1,1) }
-        it { subject.all_occurrences.should == [Time.new(1985,1,1)] }
-        it { subject.rrules.should be_blank }
+        it { expect(subject.start_time).to eq(Time.new(1985,1,1)) }
+        it { expect(subject.all_occurrences).to eq([Time.new(1985,1,1)]) }
+        it { expect(subject.rrules).to be_blank }
       end
 
       context args: {repeat: '0', dates: ['1-1-1985', '31-12-1985'], interval: '5 (ignore this)'} do
-        it { subject.start_time.should == Time.new(1985,1,1) }
-        it { subject.all_occurrences.should == [Time.new(1985,1,1), Time.new(1985,12,31)] }
-        it { subject.rrules.should be_blank }
+        it { expect(subject.start_time).to eq(Time.new(1985,1,1)) }
+        it { expect(subject.all_occurrences).to eq([Time.new(1985,1,1), Time.new(1985,12,31)]) }
+        it { expect(subject.rrules).to be_blank }
       end
 
       context args: {repeat: '0', dates: ['1-1-1985', '31-12-1985'], start_time: '12:00', end_time: '14:00', interval: '5 (ignore this)'} do
-        it      { subject.start_time.should == Time.new(1985,1,1,12,0) }
-        it      { subject.duration.should == 7200 }
-        it      { subject.all_occurrences.should == [Time.new(1985,1,1,12,0), Time.new(1985,12,31,12,0)] }
-        it      { subject.rrules.should be_blank }
-        specify { schedule.occurring_between?(helpers.parse_in_zone('1985-1-1 12:00'), helpers.parse_in_zone('1985-6-25 14:00')).should be_truthy }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-1 12:00')).should be_truthy }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-6-6 15:00')).should be_falsey }
+        it      { expect(subject.start_time).to eq(Time.new(1985,1,1,12,0)) }
+        it      { expect(subject.duration).to eq(7200) }
+        it      { expect(subject.all_occurrences).to eq([Time.new(1985,1,1,12,0), Time.new(1985,12,31,12,0)]) }
+        it      { expect(subject.rrules).to be_blank }
+        specify { expect(schedule.occurring_between?(helpers.parse_in_zone('1985-1-1 12:00'), helpers.parse_in_zone('1985-6-25 14:00'))).to be_truthy }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-1-1 12:00'))).to be_truthy }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-6-6 15:00'))).to be_falsey }
       end
 
       context args: {repeat: '1'} do
-        it { subject.start_time.should == Date.today.to_time }
-        it { subject.rrules.should == [IceCube::Rule.daily] }
+        it { expect(subject.start_time).to eq(Date.today.to_time) }
+        it { expect(subject.rrules).to eq([IceCube::Rule.daily]) }
       end
 
       context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day', interval: '3'} do
-        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
-        it      { subject.rrules.should == [IceCube::Rule.daily(3)] }
-        specify  { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+        it      { expect(subject.start_time).to eq(Date.new(1985,1,1).to_time) }
+        it      { expect(subject.rrules).to eq([IceCube::Rule.daily(3)]) }
+        specify  { expect(schedule.first(3)).to eq([Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time)) }
       end
 
       context args: {repeat: "1", start_date: "1-1-1985", interval_unit: "day", interval: "3", end_date: "29-12-1985", ends: "eventually"} do
-        it { subject.start_time.should == Date.new(1985,1,1).to_time }
+        it { expect(subject.start_time).to eq(Date.new(1985,1,1).to_time) }
         # Rails 4.1 removes Date.current.to_time_in_current_zone in favour of Date.in_time_zone
         it do
           if Date.current.respond_to?(:in_time_zone)
-            subject.rrules.should == [ IceCube::Rule.daily(3).until(Date.new(1985,12,29).in_time_zone) ]
+            expect(subject.rrules).to eq([ IceCube::Rule.daily(3).until(Date.new(1985,12,29).in_time_zone) ])
           else
-            subject.rrules.should == [ IceCube::Rule.daily(3).until(Date.new(1985,12,29).to_time_in_current_zone) ]
+            expect(subject.rrules).to eq([ IceCube::Rule.daily(3).until(Date.new(1985,12,29).to_time_in_current_zone) ])
           end
         end
-        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+        specify { expect(schedule.first(3)).to eq([Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time)) }
       end
 
       context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day', interval: '3', until_date: '29-12-1985', ends: 'never'} do
-        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
-        it      { subject.rrules.should == [IceCube::Rule.daily(3)] }
-        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time) }
+        it      { expect(subject.start_time).to eq(Date.new(1985,1,1).to_time) }
+        it      { expect(subject.rrules).to eq([IceCube::Rule.daily(3)]) }
+        specify { expect(schedule.first(3)).to eq([Date.civil(1985,1,1), Date.civil(1985,1,4), Date.civil(1985,1,7)].map(&:to_time)) }
       end
 
       context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'week', interval: '3', monday: '1', wednesday: '1', friday: '1'} do
-        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
-        it      { subject.rrules.should == [IceCube::Rule.weekly(3).day(:monday, :wednesday, :friday)] }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-2')).should be_truthy }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-4')).should be_truthy }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-7')).should be_falsey }
-        specify { schedule.occurs_at?(helpers.parse_in_zone('1985-1-21')).should be_truthy }
+        it      { expect(subject.start_time).to eq(Date.new(1985,1,1).to_time) }
+        it      { expect(subject.rrules).to eq([IceCube::Rule.weekly(3).day(:monday, :wednesday, :friday)]) }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-1-2'))).to be_truthy }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-1-4'))).to be_truthy }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-1-7'))).to be_falsey }
+        specify { expect(schedule.occurs_at?(helpers.parse_in_zone('1985-1-21'))).to be_truthy }
       end
 
       context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'day'} do
-        it { subject.rrules.should == [IceCube::Rule.daily(1)] }
+        it { expect(subject.rrules).to eq([IceCube::Rule.daily(1)]) }
       end
 
       context args: {repeat: '1', start_date: '1-1-1985', interval_unit: 'year'} do
-        it      { subject.start_time.should == Date.new(1985,1,1).to_time }
-        it      { subject.rrules.should == [IceCube::Rule.yearly.day_of_month(1).month_of_year(1)] }
-        specify { schedule.first(3).should == [Date.civil(1985,1,1), Date.civil(1986,1,1), Date.civil(1987,1,1)].map(&:to_time) }
+        it      { expect(subject.start_time).to eq(Date.new(1985,1,1).to_time) }
+        it      { expect(subject.rrules).to eq([IceCube::Rule.yearly.day_of_month(1).month_of_year(1)]) }
+        specify { expect(schedule.first(3)).to eq([Date.civil(1985,1,1), Date.civil(1986,1,1), Date.civil(1987,1,1)].map(&:to_time)) }
       end
 
       context args: {repeat: '1', interval_unit: 'day', start_date: '2012-09-27', yearly_start_month: '12', yearly_start_month_day: '1', yearly_end_month: '4', yearly_end_month_day: '21'} do
-        it { subject.start_time.should == Time.new(2012,9,27) }
-        it { subject.rrules.should == [IceCube::Rule.daily.month_of_year(12,1,2,3,4)] }
-        it { subject.exrules.should == [IceCube::Rule.daily.month_of_year(4).day_of_month(*22..31)] }
+        it { expect(subject.start_time).to eq(Time.new(2012,9,27)) }
+        it { expect(subject.rrules).to eq([IceCube::Rule.daily.month_of_year(12,1,2,3,4)]) }
+        it { expect(subject.exrules).to eq([IceCube::Rule.daily.month_of_year(4).day_of_month(*22..31)]) }
       end
 
       context "all_day", pending: "Work in progress"
@@ -104,7 +104,7 @@ describe ScheduledModel do
       let(:scheduled_model) { ScheduledModel.new.tap { |m| m.schedule_attributes = RSpec.current_example.metadata[:args] } }
       subject               { scheduled_model }
 
-      it { subject.schedule.should == IceCube::Schedule.new(Date.new(1985,1,1).to_time).tap { |s| s.add_recurrence_rule IceCube::Rule.daily(3) }  }
+      it { expect(subject.schedule).to eq(IceCube::Schedule.new(Date.new(1985,1,1).to_time).tap { |s| s.add_recurrence_rule IceCube::Rule.daily(3) })  }
     end
 
   end
@@ -117,25 +117,25 @@ describe ScheduledModel do
 
     context "for a single date" do
       before { schedule.add_recurrence_time(Date.tomorrow.to_time) }
-      it     { should == OpenStruct.new(repeat: 0, interval: 1, date: Date.tomorrow, dates: [Date.tomorrow], start_date: Date.today, all_day: true) }
-      it     { subject.date.should be_a(Date) }
+      it     { is_expected.to eq(OpenStruct.new(repeat: 0, interval: 1, date: Date.tomorrow, dates: [Date.tomorrow], start_date: Date.today, all_day: true)) }
+      it     { expect(subject.date).to be_a(Date) }
     end
 
     context "when it repeats daily" do
       before do
         schedule.add_recurrence_rule(IceCube::Rule.daily(4))
       end
-      it { should == OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'never', date: Date.today, all_day: true) }
-      it { subject.start_date.should be_a(Date) }
+      it { is_expected.to eq(OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'never', date: Date.today, all_day: true)) }
+      it { expect(subject.start_date).to be_a(Date) }
     end
 
     context "when it repeats with an end date" do
       before do
         schedule.add_recurrence_rule(IceCube::Rule.daily(4).until((Date.today+10).to_time))
       end
-      it { should == OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'eventually', end_date: Date.today+10, date: Date.today, all_day: true) }
-      it { subject.start_date.should be_a(Date) }
-      it { subject.end_date.should be_a(Date) }
+      it { is_expected.to eq(OpenStruct.new(repeat: 1, start_date: Date.tomorrow, interval_unit: 'day', interval: 4, ends: 'eventually', end_date: Date.today+10, date: Date.today, all_day: true)) }
+      it { expect(subject.start_date).to be_a(Date) }
+      it { expect(subject.end_date).to be_a(Date) }
     end
 
     context "when it repeats weekly" do
@@ -144,7 +144,7 @@ describe ScheduledModel do
         schedule.add_recurrence_rule(IceCube::Rule.weekly(4).day(:monday, :wednesday, :friday))
       end
       it do
-        should == OpenStruct.new(
+        is_expected.to eq(OpenStruct.new(
           :repeat        => 1,
           :start_date    => Date.tomorrow,
           :interval_unit => 'week',
@@ -156,7 +156,7 @@ describe ScheduledModel do
           :all_day       => true,
 
           :date          => Date.today #for the form
-        )
+        ))
       end
     end
 
@@ -166,7 +166,7 @@ describe ScheduledModel do
         schedule.add_recurrence_rule(IceCube::Rule.yearly)
       end
       it do
-        should == OpenStruct.new(
+        is_expected.to eq(OpenStruct.new(
           :repeat        => 1,
           :start_date    => Date.tomorrow,
           :interval_unit => 'year',
@@ -175,7 +175,7 @@ describe ScheduledModel do
           :all_day       => true,
 
           :date          => Date.today #for the form
-        )
+        ))
       end
     end
 
@@ -183,37 +183,37 @@ describe ScheduledModel do
       it "should have yearly start and end months" do
         schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(12,1,2))
 
-        subject.yearly_start_month.should == 12
-        subject.yearly_end_month.should == 2
+        expect(subject.yearly_start_month).to eq(12)
+        expect(subject.yearly_end_month).to eq(2)
       end
 
       it "should have a yearly start date" do
         schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(11,12,1,2))
         schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(11).day_of_month(*1..6))
 
-        subject.yearly_start_month.should == 11
-        subject.yearly_start_month_day.should == 7
+        expect(subject.yearly_start_month).to eq(11)
+        expect(subject.yearly_start_month_day).to eq(7)
       end
 
       it "should have a yearly end date" do
         schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
         schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(3).day_of_month(*26..31))
 
-        subject.yearly_end_month.should == 3
-        subject.yearly_end_month_day.should == 25
+        expect(subject.yearly_end_month).to eq(3)
+        expect(subject.yearly_end_month_day).to eq(25)
       end
 
       it "should have no yearly start day for months only" do
         schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
 
-        subject.yearly_start_month_day.should be_nil
+        expect(subject.yearly_start_month_day).to be_nil
       end
 
       it "should have a yearly start day on the first when end day is set" do
         schedule.add_recurrence_rule(IceCube::Rule.daily.month_of_year(1,2,3))
         schedule.add_exception_rule(IceCube::Rule.daily.month_of_year(3).day_of_month(*26..31))
 
-        subject.yearly_start_month_day.should == 1
+        expect(subject.yearly_start_month_day).to eq(1)
       end
     end