iso8601 0.8.7 → 0.9.0

data/spec/iso8601/hours_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe ISO8601::Hours do
+  describe 'Atomic' do
+    let(:subject) { ISO8601::Hours.new(1) }
+
+    it "should respond to the Atomic interface" do
+      [:factor,
+       :to_seconds,
+       :symbol,
+       :to_i,
+       :to_f,
+       :to_s,
+       :value,
+       :<=>,
+       :eql?,
+       :hash,
+       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+    end
+  end
+
+  describe '#factor' do
+    it "should return the Hour factor" do
+      expect(ISO8601::Hours.new(2).factor).to eq(3600)
+    end
+
+    it "should return the amount of seconds" do
+      expect(ISO8601::Hours.new(2).to_seconds).to eq(7200)
+      expect(ISO8601::Hours.new(-2).to_seconds).to eq(-7200)
+    end
+  end
+
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Hours.new(1).symbol).to eq(:H)
+    end
+  end
+
+  describe '#hash' do
+    it "should build hash identity by value" do
+      expect(ISO8601::Hours.new(3).hash).to eq(ISO8601::Hours.new(3).hash)
+    end
+  end
+end

data/spec/iso8601/minutes_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe ISO8601::Minutes do
+  describe 'Atomic' do
+    let(:subject) { ISO8601::Minutes.new(1) }
+
+    it "should respond to the Atomic interface" do
+      [:factor,
+       :to_seconds,
+       :symbol,
+       :to_i,
+       :to_f,
+       :to_s,
+       :value,
+       :<=>,
+       :eql?,
+       :hash,
+       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+    end
+  end
+
+  describe '#factor' do
+    it "should return the Minute factor" do
+      expect(ISO8601::Minutes.new(2).factor).to eq(60)
+    end
+
+    it "should return the amount of seconds" do
+      expect(ISO8601::Minutes.new(2).to_seconds).to eq(120)
+      expect(ISO8601::Minutes.new(-2).to_seconds).to eq(-120)
+    end
+  end
+
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Minutes.new(1).symbol).to eq(:M)
+    end
+  end
+
+  describe '#hash' do
+    it "should build hash identity by value" do
+      expect(ISO8601::Minutes.new(3).hash).to eq(ISO8601::Minutes.new(3).hash)
+    end
+  end
+end

data/spec/iso8601/months_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe ISO8601::Months do
+  let(:common_year) { ISO8601::DateTime.new('2010-01-01') }
+  let(:leap_year) { ISO8601::DateTime.new('2000-01-01') }
+
+  let(:common_february) { ISO8601::DateTime.new('2010-02-01') }
+  let(:leap_february) { ISO8601::DateTime.new('2000-02-01') }
+
+  describe 'Atomic' do
+    let(:subject) { ISO8601::Months.new(1) }
+
+    it "should respond to the Atomic interface" do
+      [:factor,
+       :to_seconds,
+       :symbol,
+       :to_i,
+       :to_f,
+       :to_s,
+       :value,
+       :<=>,
+       :eql?,
+       :hash,
+       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+    end
+  end
+
+  describe '#factor' do
+    it "should return the Month factor" do
+      expect { ISO8601::Months.new(1).factor }.to_not raise_error
+      expect(ISO8601::Months.new(2).factor).to eq(2628000)
+    end
+
+    it "should return the Month factor for a common year" do
+      expect(ISO8601::Months.new(1).factor(common_year)).to eq(2678400)
+    end
+
+    it "should return the Month factor for a leap year" do
+      expect(ISO8601::Months.new(1).factor(leap_year)).to eq(2678400)
+    end
+
+    it "should return the Month factor based on february for a common year" do
+      expect(ISO8601::Months.new(1).factor(common_february)).to eq(2419200)
+    end
+
+    it "should return the Month factor based on february for a leap year" do
+      expect(ISO8601::Months.new(1).factor(leap_february)).to eq(2505600)
+    end
+  end
+
+  describe '#to_seconds' do
+    it "should return the amount of seconds" do
+      expect(ISO8601::Months.new(2).to_seconds).to eq(5256000)
+    end
+
+    it "should return the amount of seconds for a common year" do
+      expect(ISO8601::Months.new(2).to_seconds(common_year)).to eq(5097600)
+    end
+
+    it "should return the amount of seconds for a leap year" do
+      expect(ISO8601::Months.new(2).to_seconds(leap_year)).to eq(5184000)
+    end
+
+    it "should return the amount of seconds based on februrary for a common year" do
+      expect(ISO8601::Months.new(2).to_seconds(common_february)).to eq(5097600)
+    end
+
+    it "should return the amount of seconds based on february for a leap year" do
+      expect(ISO8601::Months.new(2).to_seconds(leap_february)).to eq(5184000)
+      expect(ISO8601::Months.new(12).to_seconds(leap_february)).to eq(31622400)
+      expect(ISO8601::Months.new(12).to_seconds(leap_february)).to eq(ISO8601::Years.new(1).to_seconds(leap_year))
+    end
+  end
+
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Months.new(1).symbol).to eq(:M)
+    end
+  end
+
+  describe '#hash' do
+    it "should build hash identity by value" do
+      expect(ISO8601::Months.new(3).hash).to eq(ISO8601::Months.new(3).hash)
+    end
+  end
+end

data/spec/iso8601/seconds_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe ISO8601::Seconds do
+  describe 'Atomic' do
+    let(:subject) { ISO8601::Seconds.new(1) }
+
+    it "should respond to the Atomic interface" do
+      [:factor,
+       :to_seconds,
+       :symbol,
+       :to_i,
+       :to_f,
+       :to_s,
+       :value,
+       :<=>,
+       :eql?,
+       :hash,
+       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+    end
+  end
+
+  describe '#factor' do
+    it "should return the Second factor" do
+      expect(ISO8601::Seconds.new(2).factor).to eq(1)
+    end
+
+    it "should return the amount of seconds" do
+      expect(ISO8601::Seconds.new(2).to_seconds).to eq(2)
+      expect(ISO8601::Seconds.new(-2).to_seconds).to eq(-2)
+    end
+  end
+
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Seconds.new(1).symbol).to eq(:S)
+    end
+  end
+
+  describe '#hash' do
+    it "should build hash identity by value" do
+      expect(ISO8601::Seconds.new(3).hash).to eq(ISO8601::Seconds.new(3).hash)
+    end
+  end
+end

data/spec/iso8601/time_interval_spec.rb

@@ -0,0 +1,416 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe ISO8601::TimeInterval do
+  describe 'pattern initialization' do
+    it "should raise a ISO8601::Errors::UnknownPattern if it not a valid interval pattern" do
+      # Invalid separators
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00ZP1Y2M10DT2H30M') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z-P1Y2M10D') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z~P1Y2M10D') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('P1Y2M10DT2H30M2007-03-01T13:00:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('P1Y2M10D-2007-03-01T13:00:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('P1Y2M10D~2007-03-01T13:00:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z2008-05-11T15:30:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z-2008-05-11T15:30:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z~2008-05-11T15:30:00Z') }
+        .to raise_error(ISO8601::Errors::UnknownPattern)
+    end
+
+    describe 'with duration' do
+      it "should raise a ISO8601::Errors::UnknownPattern for any unknown pattern" do
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+      end
+    end
+
+    describe 'with DateTimes' do
+      it "should raise a ISO8601::Errors::UnknownPattern for any unknown pattern" do
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/2010-0-09') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/2010-05-09T103012+0400') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/2014-W15-02T10:11:12Z') }
+          .to raise_error(ISO8601::Errors::UnknownPattern)
+      end
+    end
+
+    it "should raise a ISO8601::Errors::UnknownPattern if start time and end time are durations" do
+      expect { ISO8601::TimeInterval.parse('P1Y2M10D/P1Y2M10D') }.to raise_error(ISO8601::Errors::UnknownPattern)
+      expect { ISO8601::TimeInterval.parse('P1Y0.5M/P1Y0.5M') }.to raise_error(ISO8601::Errors::UnknownPattern)
+    end
+
+    context "allowed patterns" do
+      it "should parse <start>/<duration>" do
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P0.5Y') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y0.5M') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y0,5M') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1D') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1DT1H1M1.0S') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1DT1H1M1,0S') }.to_not raise_error
+      end
+
+      it "should parse <duration>/<end>" do
+        expect { ISO8601::TimeInterval.parse('P1Y0,5M/2010-05-09T10:30:12+04') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M1D/2010-05-09T10:30:12+04:00') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M0.5D/2010-05-09T10:30:12-04:00') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M0,5D/2010-05-09T10:30:12-00:00') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M1DT1H/-2014-05-31T16:26:00Z') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M1DT0.5H/2014-05-31T16:26:10.5Z') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('P1Y1M1DT0,5H/2014-05-31T16:26:10,5Z') }.to_not raise_error
+      end
+
+      it "should parse <start>/<end>" do
+        expect { ISO8601::TimeInterval.parse('2014-001/2010-05-09T10:30') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2014121/2010-05-09T10:30:12') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('2014-121T10:11:12Z/2010-05-09T10:30:12Z') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('20100509T103012+0400/2010-05-09T10:30:12+04') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('20100509/2010-05-09T10:30:12+04:00') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('T103012+0400/2010-05-09T10:30:12-04:00') }.to_not raise_error
+        expect { ISO8601::TimeInterval.parse('T103012+04/2010-05-09T10:30:12-00:00') }.to_not raise_error
+      end
+    end
+  end
+
+  describe 'initialization with a ISO8601::Duration' do
+    # it "should raise a ISO8601::Errors::TypeError if parameter is not a ISO8601::Duration" do
+    #   datetime = ISO8601::DateTime.new('2010-05-09T10:30:12Z')
+
+    #   expect { ISO8601::TimeInterval.from_duration('hi', {}) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration([], {}) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration(datetime, {}) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration({}, {}) }.to raise_error(ISO8601::Errors::TypeError)
+    # end
+
+    # it "should raise an ISO8601::Errors::TypeError if the time hash is no valid" do
+    #   duration = ISO8601::Duration.new('P1Y1M1DT0.5H')
+    #   datetime = ISO8601::DateTime.new('2010-05-09T10:30:12Z')
+
+    #   expect { ISO8601::TimeInterval.from_duration(duration, { time: datetime }) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration(duration, { start_time: nil }) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration(duration, { start_time: datetime, end_time: datetime }) }.to raise_error(ISO8601::Errors::TypeError)
+    #   expect { ISO8601::TimeInterval.from_duration(duration, {}) }.to raise_error(ISO8601::Errors::TypeError)
+    # end
+
+    it "should initialize with a valid duration and time" do
+      time = ISO8601::DateTime.new('2010-05-09T10:30:12Z')
+      duration = ISO8601::Duration.new('P1M')
+
+      expect { ISO8601::TimeInterval.from_duration(time, duration) }.to_not raise_error
+      expect { ISO8601::TimeInterval.from_duration(duration, time) }.to_not raise_error
+    end
+  end
+
+  describe 'initialization with a ISO8601::DateTime' do
+    it "should raise a ISO8601::Errors::TypeError if parameters are not an ISO8601::DateTime instance" do
+      duration = ISO8601::Duration.new('P1Y1M1DT0.5H')
+      datetime = ISO8601::DateTime.new('2010-05-09T10:30:12Z')
+
+      expect { ISO8601::TimeInterval.from_datetimes(duration, datetime) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ISO8601::TimeInterval.from_datetimes(datetime, duration) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ISO8601::TimeInterval.from_datetimes(datetime, 'Hello!') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ISO8601::TimeInterval.from_datetimes({}, datetime) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should initialize class with a valid datetimes" do
+      datetime = ISO8601::DateTime.new('2010-05-09T10:30:12Z')
+      datetime2 = ISO8601::DateTime.new('2010-05-15T10:30:12Z')
+
+      expect { ISO8601::TimeInterval.from_datetimes(datetime, datetime2) }.to_not raise_error
+      expect { ISO8601::TimeInterval.from_datetimes(datetime2, datetime) }.to_not raise_error
+    end
+  end
+
+  describe "#to_f" do
+    it "should calculate the size of time interval" do
+      hour = (60 * 60).to_f
+      pattern = 'PT1H/2010-05-09T10:30:00Z'
+      pattern2 = '2010-05-09T11:30:00Z/PT1H'
+      pattern3 = '2010-05-09T11:30:00Z/2010-05-09T12:30:00Z'
+
+      expect(ISO8601::TimeInterval.parse(pattern).to_f).to eq(hour)
+      expect(ISO8601::TimeInterval.parse(pattern2).to_f).to eq(hour)
+      expect(ISO8601::TimeInterval.parse(pattern3).to_f).to eq(hour)
+    end
+
+    it "should be 0" do
+      expect(ISO8601::TimeInterval.parse('2015-01-01/2015-01-01').to_f).to eq(0)
+    end
+  end
+
+  describe "#empty?" do
+    it "should check if the interval is empty" do
+      expect(ISO8601::TimeInterval.parse('2015-01-01/2015-01-01').empty?).to be_truthy
+      expect(ISO8601::TimeInterval.parse('2015-01-01/2015-01-02').empty?).to be_falsy
+    end
+  end
+
+  describe "#start_time" do
+    it "should return always a ISO8601::DateTime object" do
+      pattern = 'PT1H/2010-05-09T10:30:00Z'
+      pattern2 = '2010-05-09T11:30:00Z/PT1H'
+      pattern3 = '2010-05-09T11:30:00Z/2010-05-09T12:30:00Z'
+
+      expect(ISO8601::TimeInterval.parse(pattern).first).to be_an_instance_of(ISO8601::DateTime)
+      expect(ISO8601::TimeInterval.parse(pattern2).first).to be_an_instance_of(ISO8601::DateTime)
+      expect(ISO8601::TimeInterval.parse(pattern3).first).to be_an_instance_of(ISO8601::DateTime)
+    end
+
+    it "should calculate correctly the start_time" do
+      start_time = ISO8601::DateTime.new('2010-05-09T10:30:00Z')
+      pattern = 'PT1H/2010-05-09T11:30:00Z'
+      pattern2 = '2010-05-09T10:30:00Z/PT1H'
+      pattern3 = '2010-05-09T10:30:00Z/2010-05-09T12:30:00Z'
+
+      expect(ISO8601::TimeInterval.parse(pattern).first).to eq(start_time)
+      expect(ISO8601::TimeInterval.parse(pattern2).first).to eq(start_time)
+      expect(ISO8601::TimeInterval.parse(pattern3).first).to eq(start_time)
+    end
+  end
+
+  describe "#last" do
+    it "should return always a ISO8601::DateTime object" do
+      pattern = 'PT1H/2010-05-09T10:30:00Z'
+      pattern2 = '2010-05-09T11:30:00Z/PT1H'
+      pattern3 = '2010-05-09T11:30:00Z/2010-05-09T12:30:00Z'
+
+      expect(ISO8601::TimeInterval.parse(pattern).last).to be_an_instance_of(ISO8601::DateTime)
+      expect(ISO8601::TimeInterval.parse(pattern2).last).to be_an_instance_of(ISO8601::DateTime)
+      expect(ISO8601::TimeInterval.parse(pattern3).last).to be_an_instance_of(ISO8601::DateTime)
+    end
+
+    it "should calculate correctly the last datetime" do
+      end_time = ISO8601::DateTime.new('2010-05-09T10:30:00Z')
+      pattern = 'PT1H/2010-05-09T10:30:00Z'
+      pattern2 = '2010-05-09T09:30:00Z/PT1H'
+      pattern3 = '2010-05-09T09:30:00Z/2010-05-09T10:30:00Z'
+
+      expect(ISO8601::TimeInterval.parse(pattern).last).to eq(end_time)
+      expect(ISO8601::TimeInterval.parse(pattern2).last).to eq(end_time)
+      expect(ISO8601::TimeInterval.parse(pattern3).last).to eq(end_time)
+    end
+  end
+
+  describe "#to_s" do
+    it "should return the pattern if TimeInterval is initialized with a pattern" do
+      pattern = 'P1Y1M1DT0,5H/2014-05-31T16:26:10,5Z'
+      pattern2 = '2007-03-01T13:00:00Z/P1Y0,5M'
+
+      expect(ISO8601::TimeInterval.parse(pattern).to_s).to eq(pattern)
+      expect(ISO8601::TimeInterval.parse(pattern2).to_s).to eq(pattern2)
+    end
+
+    it "should build the pattern and return if TimeInterval is initialized with objects" do
+      duration = ISO8601::Duration.new('P1Y1M1DT0.5H')
+      datetime = ISO8601::DateTime.new('2010-05-09T10:30:12+00:00')
+      datetime2 = ISO8601::DateTime.new('2010-05-15T10:30:12+00:00')
+
+      expect(ISO8601::TimeInterval.from_duration(duration, datetime).to_s).to eq('P1Y1M1DT0.5H/2010-05-09T10:30:12+00:00')
+      expect(ISO8601::TimeInterval.from_duration(datetime, duration).to_s).to eq('2010-05-09T10:30:12+00:00/P1Y1M1DT0.5H')
+      expect(ISO8601::TimeInterval.from_datetimes(datetime, datetime2).to_s).to eq('2010-05-09T10:30:12+00:00/2010-05-15T10:30:12+00:00')
+    end
+  end
+
+  describe "compare Time Intervals" do
+    before(:each) do
+      @small = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      @big = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT2H')
+    end
+
+    it "should raise TypeError when compared object is not a ISO8601::TimeInterval" do
+      expect { @small < 'Hello!' }.to raise_error(ArgumentError)
+      expect { @small > 'Hello!' }.to raise_error(ArgumentError)
+    end
+
+    it "should check what interval is bigger" do
+      expect(@small <=> @big).to eq(-1)
+      expect(@big <=> @small).to eq(1)
+      expect(@big <=> @big).to eq(0)
+
+      expect(@small > @big).to be_falsy
+      expect(@big > @small).to be_truthy
+      expect(@small > @small).to be_falsy
+    end
+
+    it "should check if interval is bigger or equal than other" do
+      expect(@small >= @big).to be_falsy
+      expect(@big >= @small).to be_truthy
+      expect(@small >= @small).to be_truthy
+    end
+
+    it "should check what interval is smaller" do
+      expect(@small < @big).to be_truthy
+      expect(@big < @small).to be_falsy
+      expect(@small < @small).to be_falsy
+    end
+
+    it "should check if interval is smaller or equal than other" do
+      expect(@small <= @big).to be_truthy
+      expect(@big <= @small).to be_falsy
+      expect(@small <= @small).to be_truthy
+    end
+
+    it "should check if the intervals are equals" do
+      expect(@small == @small).to be_truthy
+      expect(@small == @small.to_f).to be_falsy
+      expect(@small == @big).to be_falsy
+      expect(@small == @big.to_f).to be_falsy
+    end
+  end
+
+  describe "#eql?" do
+    it "should be equal only when start_time and end_time are the same" do
+      interval = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      interval2 = ISO8601::TimeInterval.parse('2007-03-01T14:00:00Z/PT1H')
+      interval3 = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+
+      expect(interval.eql?(interval2)).to be_falsy
+      expect(interval.eql?(interval3)).to be_truthy
+    end
+  end
+
+  describe "#include?" do
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      expect { ti.include?('hola') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.include?(123) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.include?(ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should check if a DateTime is included" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1DT1H')
+      included = DateTime.new(2007, 3, 1, 15, 0, 0)
+      included_iso8601 = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+      not_included = DateTime.new(2007, 2, 1, 15, 0, 0)
+      not_included_iso8601 = ISO8601::DateTime.new('2007-03-01T11:00:00Z')
+
+      expect(ti.include?(included)).to be_truthy
+      expect(ti.include?(included_iso8601)).to be_truthy
+      expect(ti.include?(not_included)).to be_falsy
+      expect(ti.include?(not_included_iso8601)).to be_falsy
+    end
+  end
+
+  describe "#subset?" do
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      dt = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+
+      expect { ti.subset?('2007-03-01T18:00:00Z') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.subset?(123) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.subset?(dt) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should check if an interval is subset of another one" do
+      ti = ISO8601::TimeInterval.parse('2015-01-15T00:00:00Z/P1D')
+      ti2 = ISO8601::TimeInterval.parse('2015-01-01T00:00:00Z/P1M')
+
+      expect(ti.subset?(ti)).to be_truthy
+      expect(ti.subset?(ti2)).to be_truthy
+      expect(ti2.subset?(ti)).to be_falsy
+    end
+  end
+
+  describe "#superset?" do
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      dt = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+
+      expect { ti.superset?('2007-03-01T18:00:00Z') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.superset?(123) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.superset?(dt) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should check if the interval is superset of the given one" do
+      ti = ISO8601::TimeInterval.parse('2015-01-01T00:00:00Z/P1M')
+      ti2 = ISO8601::TimeInterval.parse('2015-01-15T00:00:00Z/P1D')
+      ti3 = ISO8601::TimeInterval.parse('2015-03-01T00:00:00Z/P1D')
+
+      expect(ti.superset?(ti)).to be_truthy
+      expect(ti.superset?(ti2)).to be_truthy
+      expect(ti.superset?(ti3)).to be_falsy
+    end
+  end
+
+  describe "#intersect?" do
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      dt = DateTime.new(2007, 2, 1, 15, 0, 0)
+      dt_iso8601 = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+
+      expect { ti.intersect?('hola') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.intersect?(123) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.intersect?(dt) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.intersect?(dt_iso8601) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should check if two intervals intersect" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1DT1H')
+      included = ISO8601::TimeInterval.parse('2007-03-01T14:00:00Z/PT2H')
+      overlaped = ISO8601::TimeInterval.parse('2007-03-01T18:00:00Z/P1DT1H')
+      not_overlaped = ISO8601::TimeInterval.parse('2007-03-14T14:00:00Z/PT2H')
+
+      expect(ti.intersect?(included)).to be_truthy
+      expect(ti.intersect?(overlaped)).to be_truthy
+      expect(ti.intersect?(not_overlaped)).to be_falsy
+    end
+  end
+
+  describe "#intersection" do
+    let(:small) { ISO8601::TimeInterval.parse('2015-06-15/P1D') }
+    let(:big) { ISO8601::TimeInterval.parse('2015-06-01/P1M') }
+    let(:other) { ISO8601::TimeInterval.parse('2015-06-30/P1D') }
+
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      dt = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+
+      expect { ti.intersection('2007-03-01T13:00:00Z/PT1H') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.intersection(1) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.intersection(dt) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "raise IntervalError when the intervals are disjoint" do
+      expect { small.intersection(other) }.to raise_error(ISO8601::Errors::IntervalError)
+    end
+
+    it "should return the smallest when one is subset of the other" do
+      expect(small.intersection(small)).to eq(small)
+      expect(big.intersection(small)).to eq(small)
+      expect(small.intersection(big)).to eq(small)
+    end
+  end
+
+  describe "#disjoint?" do
+    it "raise TypeError when the parameter is not valid" do
+      ti = ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/PT1H')
+      dt = ISO8601::DateTime.new('2007-03-01T18:00:00Z')
+
+      expect { ti.disjoint?('2007-03-01T13:00:00Z/PT1H') }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.disjoint?(1) }.to raise_error(ISO8601::Errors::TypeError)
+      expect { ti.disjoint?(dt) }.to raise_error(ISO8601::Errors::TypeError)
+    end
+
+    it "should check if two intervals are disjoint" do
+      ti = ISO8601::TimeInterval.parse('2015-01-01T00:00:00Z/P1D')
+      ti2 = ISO8601::TimeInterval.parse('2015-02-01T00:00:00Z/P1D')
+
+      expect(ti.disjoint?(ti)).to be_falsy
+      expect(ti.disjoint?(ti2)).to be_truthy
+    end
+  end
+end