iso8601 0.7.0 → 0.8.0

data/spec/iso8601/{dateTime_spec.rb → date_time_spec.rb}

@@ -59,78 +59,77 @@ describe ISO8601::DateTime do
   context 'reduced patterns' do
     it "should parse correctly reduced dates" do
       reduced_date = ISO8601::DateTime.new('20100509')
-      reduced_date.year.should == 2010
-      reduced_date.month.should == 5
-      reduced_date.day.should == 9
+      expect(reduced_date.year).to eq(2010)
+      expect(reduced_date.month).to eq(5)
+      expect(reduced_date.day).to eq(9)
     end
     it "should parse correctly reduced times" do
       reduced_time = ISO8601::DateTime.new('T101112Z')
-      reduced_time.hour.should == 10
-      reduced_time.minute.should == 11
-      reduced_time.second.should == 12
+      expect(reduced_time.hour).to eq(10)
+      expect(reduced_time.minute).to eq(11)
+      expect(reduced_time.second).to eq(12)
     end
     it "should parse correctly reduced date times" do
       reduced_datetime = ISO8601::DateTime.new('20140531T101112Z')
-      reduced_datetime.year.should == 2014
-      reduced_datetime.month.should == 5
-      reduced_datetime.day.should == 31
-      reduced_datetime.hour.should == 10
-      reduced_datetime.minute.should == 11
-      reduced_datetime.second.should == 12
+      expect(reduced_datetime.year).to eq(2014)
+      expect(reduced_datetime.month).to eq(5)
+      expect(reduced_datetime.day).to eq(31)
+      expect(reduced_datetime.hour).to eq(10)
+      expect(reduced_datetime.minute).to eq(11)
+      expect(reduced_datetime.second).to eq(12)
     end
   end
 
   it "should return each atomic value" do
     dt = ISO8601::DateTime.new('2010-05-09T12:02:01+04:00')
-    dt.year.should == 2010
-    dt.month.should == 5
-    dt.day.should == 9
-    dt.hour.should == 12
-    dt.minute.should == 2
-    dt.second.should == 1
-    dt.zone.should == '+04:00'
+    expect(dt.year).to eq(2010)
+    expect(dt.month).to eq(5)
+    expect(dt.day).to eq(9)
+    expect(dt.hour).to eq(12)
+    expect(dt.minute).to eq(2)
+    expect(dt.second).to eq(1)
+    expect(dt.zone).to eq('+04:00')
   end
 
   it "should return the right sign for the given year" do
-    ISO8601::DateTime.new('-2014-05-31T16:26:00Z').year.should == -2014
-    ISO8601::DateTime.new('+2014-05-31T16:26:00Z').year.should == 2014
+    expect(ISO8601::DateTime.new('-2014-05-31T16:26:00Z').year).to eq(-2014)
+    expect(ISO8601::DateTime.new('+2014-05-31T16:26:00Z').year).to eq(2014)
   end
 
   it "should respond to delegated casting methods" do
     dt = ISO8601::DateTime.new('2014-12-11T10:09:08Z')
-    dt.should respond_to(:to_s, :to_time, :to_date, :to_datetime)
+    expect(dt).to respond_to(:to_s, :to_time, :to_date, :to_datetime)
   end
 
   describe '#+' do
     it "should return the result of the addition" do
-      (ISO8601::DateTime.new('2012-07-07T20:20:20Z') + 10).to_s.should == '2012-07-07T20:20:30+00:00'
-      (ISO8601::DateTime.new('2012-07-07T20:20:20.5Z') + 10).to_s.should == '2012-07-07T20:20:30.50+00:00'
-      (ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10).to_s.should == '2012-07-07T20:20:30+02:00'
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20Z') + 10).to_s).to eq('2012-07-07T20:20:30+00:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20.5Z') + 10).to_s).to eq('2012-07-07T20:20:30.50+00:00')
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20+02:00') + 10).to_s).to eq('2012-07-07T20:20:30+02:00')
     end
   end
 
   describe '#-' do
     it "should return the result of the substraction" do
-      (ISO8601::DateTime.new('2012-07-07T20:20:20Z') - 10).to_s.should == '2012-07-07T20:20:10+00:00'
+      expect((ISO8601::DateTime.new('2012-07-07T20:20:20Z') - 10).to_s).to eq('2012-07-07T20:20:10+00:00')
     end
   end
 
   describe '#to_a' do
     it "should return an array of atoms" do
       dt = ISO8601::DateTime.new('2014-05-31T19:29:39Z').to_a
-      dt.should be_kind_of(Array)
-      dt.should == [2014, 5, 31, 19, 29, 39, '+00:00']
+      expect(dt).to be_kind_of(Array)
+      expect(dt).to eq([2014, 5, 31, 19, 29, 39, '+00:00'])
     end
   end
 
   describe '#hash' do
     it "should return the datetime hash" do
       subject = ISO8601::DateTime.new('2014-08-16T20:11:10Z')
-      contrast = ::DateTime.new(2014, 8, 16, 20, 11, 10, 'Z')
+      contrast = ISO8601::DateTime.new('2014-08-16T20:11:10Z')
 
-      expect(subject).to respond_to(:hash)
+      expect(subject.hash == contrast.hash).to be_truthy
       expect(subject.hash).to eq(contrast.hash)
     end
   end
-
 end

data/spec/iso8601/duration_spec.rb

@@ -2,8 +2,9 @@
 
 require 'spec_helper'
 
-describe ISO8601::Duration do
+RSpec.describe ISO8601::Duration do
   it "should raise a ISO8601::Errors::UnknownPattern for any unknown pattern" do
+    expect { ISO8601::Duration.new('') }.to raise_error(ISO8601::Errors::UnknownPattern)
     expect { ISO8601::Duration.new('P') }.to raise_error(ISO8601::Errors::UnknownPattern)
     expect { ISO8601::Duration.new('PT') }.to raise_error(ISO8601::Errors::UnknownPattern)
     expect { ISO8601::Duration.new('P1YT') }.to raise_error(ISO8601::Errors::UnknownPattern)
@@ -43,33 +44,42 @@ describe ISO8601::Duration do
   end
   it "should raise a TypeError when the base is not a ISO8601::DateTime" do
     expect { ISO8601::Duration.new('P1Y1M1DT1H1M1S', ISO8601::DateTime.new('2010-01-01')) }.to_not raise_error
-    expect { ISO8601::Duration.new('P1Y1M1DT1H1M1S', '2010-01-01') }.to raise_error(TypeError)
-    expect { ISO8601::Duration.new('P1Y1M1DT1H1M1S', 2010) }.to raise_error(TypeError)
+    expect { ISO8601::Duration.new('P1Y1M1DT1H1M1S', '2010-01-01') }.to raise_error(ISO8601::Errors::TypeError)
+    expect { ISO8601::Duration.new('P1Y1M1DT1H1M1S', 2010) }.to raise_error(ISO8601::Errors::TypeError)
     expect {
       d = ISO8601::Duration.new('P1Y1M1DT1H1M1S', ISO8601::DateTime.new('2010-01-01'))
       d.base = 2012
-    }.to raise_error(TypeError)
+    }.to raise_error(ISO8601::Errors::TypeError)
   end
 
   it "should return a Duration instance from a Numeric input" do
-    ISO8601::Duration.new(36993906, ISO8601::DateTime.new('2012-01-01')).should == ISO8601::Duration.new('P1Y2M3DT4H5M6S', ISO8601::DateTime.new('2012-01-01'))
+    subject = ISO8601::Duration.new(36993906, ISO8601::DateTime.new('2012-01-01'))
+    contrast = ISO8601::Duration.new('P1Y2M3DT4H5M6S', ISO8601::DateTime.new('2012-01-01'))
+    expect(subject.to_seconds).to eq(contrast.to_seconds)
   end
 
   describe '#base' do
     it "should return the base datetime" do
       dt = ISO8601::DateTime.new('2010-01-01')
       dt2 = ISO8601::DateTime.new('2012-01-01')
-      ISO8601::Duration.new('P1Y1M1DT1H1M1S').base.should be_an_instance_of(NilClass)
-      ISO8601::Duration.new('P1Y1M1DT1H1M1S', dt).base.should be_an_instance_of(ISO8601::DateTime)
-      ISO8601::Duration.new('P1Y1M1DT1H1M1S', dt).base.should equal(dt)
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S').base).to be_an_instance_of(NilClass)
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S', dt).base).to be_an_instance_of(ISO8601::DateTime)
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S', dt).base).to eq(dt)
       d = ISO8601::Duration.new('P1Y1M1DT1H1M1S', dt).base = dt2
-      d.should equal(dt2)
+      expect(d).to eq(dt2)
+    end
+  end
+
+  describe '#pattern' do
+    it "should return the duration pattern" do
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S').pattern).to eq('P1Y1M1DT1H1M1S')
+      expect(ISO8601::Duration.new(60).pattern).to eq('PT60S')
     end
   end
 
   describe '#to_s' do
     it "should return the duration as a string" do
-      ISO8601::Duration.new('P1Y1M1DT1H1M1S').to_s.should == 'P1Y1M1DT1H1M1S'
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S').to_s).to eq('P1Y1M1DT1H1M1S')
     end
   end
 
@@ -79,165 +89,184 @@ describe ISO8601::Duration do
     end
 
     it "should return the result of the addition" do
-      (ISO8601::Duration.new('P1Y1M1DT1H1M1S') + ISO8601::Duration.new('PT10S')).to_s.should == 'P1Y1M1DT1H1M11S'
-      (ISO8601::Duration.new('P1Y1M1DT1H1M1S') + ISO8601::Duration.new('PT10S')).should be_an_instance_of(ISO8601::Duration)
+      expect((ISO8601::Duration.new('P11Y1M1DT1H1M1S') + ISO8601::Duration.new('P1Y1M1DT1H1M1S')).to_s).to eq('P12Y2M2DT2H2M2S')
+      expect((ISO8601::Duration.new('P1Y1M1DT1H1M1S') + ISO8601::Duration.new('PT10S')).to_s).to eq('P1Y1M1DT1H1M11S')
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S') + ISO8601::Duration.new('PT10S')).to be_an_instance_of(ISO8601::Duration)
     end
   end
 
   describe '#-' do
-    it "should raise an ISO8601::Errors::DurationBaseError" do
+    it "should raise an ISO8601::Errors::DurationBaseError when bases mismatch" do
       expect { ISO8601::Duration.new('PT1H', ISO8601::DateTime.new('2000-01-01')) - ISO8601::Duration.new('PT1H') }.to raise_error(ISO8601::Errors::DurationBaseError)
     end
 
     it "should return the result of the substraction" do
-      (ISO8601::Duration.new('P1Y1M1DT1H1M1S') - ISO8601::Duration.new('PT10S')).should be_an_instance_of(ISO8601::Duration)
-      (ISO8601::Duration.new('P1Y1M1DT1H1M11S') - ISO8601::Duration.new('PT10S')).to_s.should == 'P1Y1M1DT1H1M1S'
-      (ISO8601::Duration.new('PT12S') - ISO8601::Duration.new('PT12S')).to_s.should == 'PT0S'
-      (ISO8601::Duration.new('PT12S') - ISO8601::Duration.new('PT1S')).to_s.should == 'PT11S'
-      (ISO8601::Duration.new('PT1S') - ISO8601::Duration.new('PT12S')).to_s.should == '-PT11S'
-      (ISO8601::Duration.new('PT1S') - ISO8601::Duration.new('-PT12S')).to_s.should == 'PT13S'
+      expect(ISO8601::Duration.new('P1Y1M1DT1H1M1S') - ISO8601::Duration.new('PT10S')).to be_an_instance_of(ISO8601::Duration)
+      expect((ISO8601::Duration.new('P1Y1M1DT1H1M11S') - ISO8601::Duration.new('PT10S')).to_s).to eq('P1Y1M1DT1H1M1S')
+      expect((ISO8601::Duration.new('P1Y1M1DT1H1M11S') - ISO8601::Duration.new('P1Y1M1DT1H1M11S')).to_s).to eq('PT0S')
+      expect((ISO8601::Duration.new('PT12S') - ISO8601::Duration.new('PT12S')).to_s).to eq('PT0S')
+      expect((ISO8601::Duration.new('PT12S') - ISO8601::Duration.new('PT1S')).to_s).to eq('PT11S')
+      expect((ISO8601::Duration.new('PT1S') - ISO8601::Duration.new('PT12S')).to_s).to eq('-PT11S')
+      expect((ISO8601::Duration.new('PT1S') - ISO8601::Duration.new('-PT12S')).to_s).to eq('PT13S')
     end
   end
 
   describe '#to_seconds' do
     context 'positive durations' do
       it "should return the seconds of a P[n]Y duration in a common year" do
-        ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2010, 1))
+        expect(ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2010, 1))
       end
       it "should return the seconds of a P[n]Y duration in a leap year" do
-        ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 1) - Time.utc(2000, 1))
+        expect(ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(Time.utc(2002, 1) - Time.utc(2000, 1))
       end
       it "should return the seconds of a P[n]Y[n]M duration in a common year" do
-        ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 4) - Time.utc(2010, 1))
+        expect(ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds).to eq(Time.utc(2012, 4) - Time.utc(2010, 1))
       end
       it "should return the seconds of a P[n]Y[n]M duration in a leap year" do
-        ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 4) - Time.utc(2000, 1))
+        expect(ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(Time.utc(2002, 4) - Time.utc(2000, 1))
       end
       it "should return the seconds of a P[n]M duration in a common year" do
-        ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 2) - Time.utc(2012, 1))
-        ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 3) - Time.utc(2012, 1))
-        ISO8601::Duration.new('P19M', ISO8601::DateTime.new('2012-05-01')).to_seconds.should == (Time.utc(2014, 12) - Time.utc(2012, 5))
-        ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 3) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 2) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 3) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P19M', ISO8601::DateTime.new('2012-05-01')).to_seconds).to eq(Time.utc(2014, 12) - Time.utc(2012, 5))
+        expect(ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2013, 3) - Time.utc(2012, 1))
       end
       it "should return the seconds of a P[n]M duration in a leap year" do
-        ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 2) - Time.utc(2000, 1))
-        ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 3) - Time.utc(2000, 1))
-        ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2001, 3) - Time.utc(2000, 1))
+        expect(ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(Time.utc(2000, 2) - Time.utc(2000, 1))
+        expect(ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(Time.utc(2000, 3) - Time.utc(2000, 1))
+        expect(ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(Time.utc(2001, 3) - Time.utc(2000, 1))
       end
       it "should return the seconds of a P[n]Y[n]M[n]D duration" do
-        ISO8601::Duration.new('P2Y11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2014, 1, 12) - Time.utc(2012, 1))
-        ISO8601::Duration.new('P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds.should == (Time.utc(2011, 6, 2) - Time.utc(2010, 5))
+        expect(ISO8601::Duration.new('P2Y11D', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2014, 1, 12) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds).to eq(Time.utc(2011, 6, 2) - Time.utc(2010, 5))
       end
       it "should return the seconds of a P[n]D duration" do
-        ISO8601::Duration.new('P1D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 2) - Time.utc(2012, 1, 1))
-        ISO8601::Duration.new('P11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 12) - Time.utc(2012, 1, 1))
-        ISO8601::Duration.new('P3M11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 4, 12) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P1D', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 2) - Time.utc(2012, 1, 1))
+        expect(ISO8601::Duration.new('P11D', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 12) - Time.utc(2012, 1, 1))
+        expect(ISO8601::Duration.new('P3M11D', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 4, 12) - Time.utc(2012, 1))
       end
       it "should return the seconds of a P[n]W duration" do
-        ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 15) - Time.utc(2012, 1))
-        ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 2, 15) - Time.utc(2012, 2))
+        expect(ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 15) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds).to eq(Time.utc(2012, 2, 15) - Time.utc(2012, 2))
       end
 
       it "should return the seconds of a PT[n]H duration" do
-        ISO8601::Duration.new('PT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 5) - Time.utc(2012, 1))
-        ISO8601::Duration.new('P1YT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 1, 1, 5) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('PT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 1, 5) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('P1YT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2013, 1, 1, 5) - Time.utc(2012, 1))
       end
 
       it "should return the seconds of a PT[n]H[n]M duration" do
-        ISO8601::Duration.new('PT5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 5) - Time.utc(2012, 1))
-        ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 1, 5) - Time.utc(2012, 1))
-        ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == ISO8601::Duration.new('PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds
+        expect(ISO8601::Duration.new('PT5M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 1, 0, 5) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 1, 1, 5) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(ISO8601::Duration.new('PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds)
       end
 
       it "should return the seconds of a PT[n]H[n]M duration" do
-        ISO8601::Duration.new('PT10S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 0, 10) - Time.utc(2012, 1))
-        ISO8601::Duration.new('PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == 10.4
+        expect(ISO8601::Duration.new('PT10S', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2012, 1, 1, 0, 0, 10) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(10.4)
       end
     end
 
     context 'negative durations' do
       it "should return the seconds of a -P[n]Y duration" do
-        ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2008, 1) - Time.utc(2010, 1))
+        expect(ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds).to eq(Time.utc(2008, 1) - Time.utc(2010, 1))
       end
       it "should return the seconds of a -P[n]Y duration in a leap year" do
-        ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2001-01-01')).to_seconds.should == (Time.utc(1999, 1) - Time.utc(2001, 1))
+        expect(ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2001-01-01')).to_seconds).to eq(Time.utc(1999, 1) - Time.utc(2001, 1))
       end
       it "should return the seconds of a -P[n]Y[n]M duration in a common year" do
-        ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2007, 10) - Time.utc(2010, 1))
+        expect(ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds).to eq(Time.utc(2007, 10) - Time.utc(2010, 1))
       end
       it "should return the seconds of a -P[n]Y[n]M duration in a leap year" do
-        ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2001-01-01')).to_seconds.should == (Time.utc(1998, 10) - Time.utc(2001, 1))
+        expect(ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2001-01-01')).to_seconds).to eq(Time.utc(1998, 10) - Time.utc(2001, 1))
       end
       it "should return the seconds of a -P[n]M duration in a common year" do
-        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2011, 12) - Time.utc(2012, 1))
-        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 2))
-        ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2012-03-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 3))
-        ISO8601::Duration.new('-P36M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2010, 3) - Time.utc(2013, 3))
-        ISO8601::Duration.new('-P39M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2009, 12) - Time.utc(2013, 3))
-        ISO8601::Duration.new('-P156M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2000, 3) - Time.utc(2013, 3))
+        expect(ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(Time.utc(2011, 12) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-02-01')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 2))
+        expect(ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2012-03-01')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 3))
+        expect(ISO8601::Duration.new('-P36M', ISO8601::DateTime.new('2013-03-01')).to_seconds).to eq(Time.utc(2010, 3) - Time.utc(2013, 3))
+        expect(ISO8601::Duration.new('-P39M', ISO8601::DateTime.new('2013-03-01')).to_seconds).to eq(Time.utc(2009, 12) - Time.utc(2013, 3))
+        expect(ISO8601::Duration.new('-P156M', ISO8601::DateTime.new('2013-03-01')).to_seconds).to eq(Time.utc(2000, 3) - Time.utc(2013, 3))
       end
       it "should return the seconds of a -P[n]M duration in a leap year" do
-        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2000-02-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2000, 2))
-        ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2000-03-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2000, 3))
-        ISO8601::Duration.new('-P14M', ISO8601::DateTime.new('2001-03-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2001, 3))
+        expect(ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2000-02-01')).to_seconds).to eq(Time.utc(2000, 1) - Time.utc(2000, 2))
+        expect(ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2000-03-01')).to_seconds).to eq(Time.utc(2000, 1) - Time.utc(2000, 3))
+        expect(ISO8601::Duration.new('-P14M', ISO8601::DateTime.new('2001-03-01')).to_seconds).to eq(Time.utc(2000, 1) - Time.utc(2001, 3))
       end
       it "should return the seconds of a -P[n]Y[n]M[n]D duration" do
-        ISO8601::Duration.new('-P2Y11D', ISO8601::DateTime.new('2014-01-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2014, 1, 12))
-        ISO8601::Duration.new('-P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds.should == (Time.utc(2009, 3, 31) - Time.utc(2010, 5))
+        expect(ISO8601::Duration.new('-P2Y11D', ISO8601::DateTime.new('2014-01-12')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2014, 1, 12))
+        expect(ISO8601::Duration.new('-P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds).to eq(Time.utc(2009, 3, 31) - Time.utc(2010, 5))
       end
       it "should return the seconds of a -P[n]D duration" do
-        ISO8601::Duration.new('-P1D', ISO8601::DateTime.new('2012-01-02')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 2))
-        ISO8601::Duration.new('-P11D', ISO8601::DateTime.new('2012-01-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 12))
-        ISO8601::Duration.new('-P3M11D', ISO8601::DateTime.new('2012-04-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 4, 12))
+        expect(ISO8601::Duration.new('-P1D', ISO8601::DateTime.new('2012-01-02')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 2))
+        expect(ISO8601::Duration.new('-P11D', ISO8601::DateTime.new('2012-01-12')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 12))
+        expect(ISO8601::Duration.new('-P3M11D', ISO8601::DateTime.new('2012-04-12')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 4, 12))
       end
       it "should return the seconds of a -P[n]W duration" do
-        ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-01-15')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 15))
-        ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 2) - Time.utc(2012, 2, 15))
+        expect(ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-01-15')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 15))
+        expect(ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds).to eq(Time.utc(2012, 2) - Time.utc(2012, 2, 15))
       end
 
       it "should return the seconds of a -PT[n]H duration" do
-        ISO8601::Duration.new('-PT5H', ISO8601::DateTime.new('2012-01-01T05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 5))
-        ISO8601::Duration.new('-P1YT5H', ISO8601::DateTime.new('2013-01-01T05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2013, 1, 1, 5))
+        expect(ISO8601::Duration.new('-PT5H', ISO8601::DateTime.new('2012-01-01T05')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 1, 5))
+        expect(ISO8601::Duration.new('-P1YT5H', ISO8601::DateTime.new('2013-01-01T05')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2013, 1, 1, 5))
       end
 
       it "should return the seconds of a -PT[n]H[n]M duration" do
-        ISO8601::Duration.new('-PT5M', ISO8601::DateTime.new('2012-01-01T00:05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 0, 5))
-        ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01T01:05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 1, 5))
-        ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == ISO8601::Duration.new('-PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds
+        expect(ISO8601::Duration.new('-PT5M', ISO8601::DateTime.new('2012-01-01T00:05')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 1, 0, 5))
+        expect(ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01T01:05')).to_seconds).to eq(Time.utc(2012, 1) - Time.utc(2012, 1, 1, 1, 5))
+        expect(ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(ISO8601::Duration.new('-PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds)
       end
 
       it "should return the seconds of a -PT[n]H[n]M duration" do
-        ISO8601::Duration.new('-PT10S', ISO8601::DateTime.new('2012-01-01T00:00:00')).to_seconds.should == (Time.utc(2011, 12, 31, 23, 59, 50) - Time.utc(2012, 1))
-        ISO8601::Duration.new('-PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == -10.4
+        expect(ISO8601::Duration.new('-PT10S', ISO8601::DateTime.new('2012-01-01T00:00:00')).to_seconds).to eq(Time.utc(2011, 12, 31, 23, 59, 50) - Time.utc(2012, 1))
+        expect(ISO8601::Duration.new('-PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(-10.4)
       end
     end
   end
 
-  describe '#==' do
-    it "should raise an ISO8601::Errors::DurationBaseError" do
-      expect { ISO8601::Duration.new('PT1H', ISO8601::DateTime.new('2000-01-01')) == ISO8601::Duration.new('PT1H') }.to raise_error(ISO8601::Errors::DurationBaseError)
+  describe '#abs' do
+    let(:positive) { ISO8601::Duration.new('PT1H') }
+    let(:negative) { ISO8601::Duration.new('-PT1H') }
+
+    it "should return a kind of duration" do
+      expect(negative.abs).to be_instance_of(ISO8601::Duration)
     end
-    it "should return True" do
-      ISO8601::Duration.new('PT1H').should == ISO8601::Duration.new('PT1H')
+    it "should return the absolute value of the duration" do
+      expect(negative.abs).to eq(positive)
     end
   end
 
-  describe '#to_abs' do
-    it "should return a kind of duration" do
-      ISO8601::Duration.new('-PT1H').abs.should be_an_instance_of ISO8601::Duration
+  describe '#==' do
+    it "should equal by computed value" do
+      expect(ISO8601::Duration.new('PT1H') == ISO8601::Duration.new('PT1H')).to be_truthy
+      expect(ISO8601::Duration.new('PT1H') == ISO8601::Duration.new('PT60M')).to be_truthy
     end
-    it "should return the absolute value of the duration" do
-      ISO8601::Duration.new('-PT1H').abs.should == ISO8601::Duration.new('PT1H')
-      (ISO8601::Duration.new('PT1H') - ISO8601::Duration.new('PT2H')).abs.should == ISO8601::Duration.new('PT1H')
-      (ISO8601::Duration.new('PT1H') - ISO8601::Duration.new('-PT2H')).abs.should == ISO8601::Duration.new('PT3H')
+  end
+
+  describe '#eql?' do
+    it "should respond to #eql?" do
+      subject = ISO8601::Duration.new('PT1H')
+      expect(subject).to respond_to(:eql?)
     end
+    it "should equal by hash identity" do
+      expect(ISO8601::Duration.new('PT1H').eql?  ISO8601::Duration.new('PT1H')).to be_truthy
+      expect(ISO8601::Duration.new('PT1H').eql? ISO8601::Duration.new('PT60M')).to be_falsy
+    end
+
   end
 
   describe '#hash' do
-    it "should return the duration hash" do
+    it "should respond to #hash" do
       subject = ISO8601::Duration.new('PT1H')
 
       expect(subject).to respond_to(:hash)
     end
+    it "should build hash identity by value" do
+      subject = ISO8601::Duration.new('PT1H')
+      contrast = ISO8601::Duration.new('PT1H')
+
+      expect(subject.hash == contrast.hash).to be_truthy
+    end
   end
 end

data/spec/iso8601/time_spec.rb

@@ -32,52 +32,51 @@ describe ISO8601::Time do
   context 'reduced patterns' do
     it "should parse correctly reduced times" do
       reduced_time = ISO8601::Time.new('T101112Z')
-      reduced_time.hour.should == 10
-      reduced_time.minute.should == 11
-      reduced_time.second.should == 12
+      expect(reduced_time.hour).to eq(10)
+      expect(reduced_time.minute).to eq(11)
+      expect(reduced_time.second).to eq(12)
     end
   end
 
   it "should return each atomic value" do
-    dt = ISO8601::Time.new('T12:02:01+04:00', ::Date.parse('2010-05-09'))
-    dt.hour.should == 12
-    dt.minute.should == 2
-    dt.second.should == 1
-    dt.zone.should == '+04:00'
+    t = ISO8601::Time.new('T12:02:01+04:00', ::Date.parse('2010-05-09'))
+    expect(t.hour).to eq(12)
+    expect(t.minute).to eq(2)
+    expect(t.second).to eq(1)
+    expect(t.zone).to eq('+04:00')
   end
 
   it "should respond to delegated casting methods" do
-    dt = ISO8601::Time.new('T10:09:08Z')
-    dt.should respond_to(:to_s, :to_time, :to_date, :to_datetime)
+    expect(ISO8601::Time.new('T10:09:08Z')).to respond_to(:to_s, :to_time, :to_date, :to_datetime)
   end
 
   describe '#+' do
     it "should return the result of the addition" do
-      (ISO8601::Time.new('T20:20:20+02:00') + 10).to_s.should == 'T20:20:30+02:00'
-      (ISO8601::Time.new('T20:20:20.11+02:00') + 10).to_s.should == 'T20:20:30.11+02:00'
+      expect((ISO8601::Time.new('T20:20:20+02:00') + 10).to_s).to eq('T20:20:30+02:00')
+      expect((ISO8601::Time.new('T20:20:20.11+02:00') + 10).to_s).to eq('T20:20:30.11+02:00')
     end
   end
 
   describe '#-' do
     it "should return the result of the substraction" do
-      (ISO8601::Time.new('T20:20:20+01:00') - 10).to_s.should == 'T20:20:10+01:00'
-      (ISO8601::Time.new('T20:20:20.11+02:00') - 10).to_s.should == 'T20:20:10.11+02:00'
+      expect((ISO8601::Time.new('T20:20:20+01:00') - 10).to_s).to eq('T20:20:10+01:00')
+      expect((ISO8601::Time.new('T20:20:20.11+02:00') - 10).to_s).to eq('T20:20:10.11+02:00')
     end
   end
 
   describe '#to_a' do
     it "should return an array of atoms" do
-      ISO8601::Time.new('T19:29:39Z').to_a.should == [19, 29, 39, '+00:00']
+      expect(ISO8601::Time.new('T19:29:39Z').to_a).to eq([19, 29, 39, '+00:00'])
     end
   end
 
   describe '#atoms' do
     it "should return an array of atoms" do
-      ISO8601::Time.new('T19:29:39+04:00').atoms.should == [19, 29, 39, '+04:00']
-      ISO8601::Time.new('T19:29:39Z').atoms.should == [19, 29, 39, 'Z']
-      ISO8601::Time.new('T19:29:39').atoms.should == [19, 29, 39]
-      ISO8601::Time.new('T19:29').atoms.should == [19, 29]
-      ISO8601::Time.new('T19').atoms.should == [19]
+      expect(ISO8601::Time.new('T19:29:39+04:00').atoms).to eq([19, 29, 39, '+04:00'])
+      expect(ISO8601::Time.new('T19:29:39Z').atoms).to eq([19, 29, 39, 'Z'])
+      expect(ISO8601::Time.new('T19:29:39').atoms).to eq([19, 29, 39])
+      expect(ISO8601::Time.new('T19:29').atoms).to eq([19, 29])
+      expect(ISO8601::Time.new('T19').atoms).to eq([19])
     end
   end
 
@@ -87,6 +86,11 @@ describe ISO8601::Time do
 
       expect(subject).to respond_to(:hash)
     end
-  end
+    it "should return the same hash" do
+      subject = ISO8601::Time.new('T20:11:10Z')
+      contrast = ISO8601::Time.new('T20:11:10Z')
 
+      expect(subject.hash).to eq(contrast.hash)
+    end
+  end
 end