openehr 1.1.0

data/spec/lib/openehr/rm/data_types/quantity/date_time/dv_date_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvDate do
+  before(:each) do
+    @dv_date = DvDate.new(:value => '2009-09-28')
+  end
+
+  it 'should be an instance of DvDate' do
+    @dv_date.should be_an_instance_of DvDate
+  end
+
+  it 'value should be' do
+    @dv_date.value.should == '2009-09-28'
+  end
+
+  it 'year should be 2009' do
+    @dv_date.year.should be_equal 2009
+  end
+
+  it 'month should be 9' do
+    @dv_date.month.should be_equal 9
+  end
+
+  it 'day should be 28' do
+    @dv_date.day.should be_equal 28
+  end
+
+  it 'magnitude should 734045' do
+    @dv_date.magnitude.should == 734045
+  end
+
+  it 'diff should P0Y0M1W11D' do
+    diff_date = DvDate.new(:value => '2009-10-09')
+    @dv_date.diff(diff_date).value.should == 'P0Y0M1W11D'
+  end
+
+  it 'should process leap year' do
+    @dv_date.value = '2004-02-28'
+    diff_date = DvDate.new(:value => '2004-03-01')
+    @dv_date.diff(diff_date).value.should == 'P0Y0M0W2D'
+  end
+
+  it 'should process year'do
+    diff_date = DvDate.new(:value => '2007-12-31')
+    @dv_date.diff(diff_date).value.should == 'P1Y8M4W28D'
+  end
+
+  it 'should be P0Y11M4W31D' do
+    diff_date = DvDate.new(:value => '2008-09-30')
+    @dv_date.diff(diff_date).value.should == 'P0Y11M4W29D'
+  end
+
+  it 'should be P1Y0M0W1D' do
+    diff_date = DvDate.new(:value => '2010-09-29')
+    @dv_date.diff(diff_date).value.should == 'P1Y0M0W1D'
+  end
+
+  it 'should be P0Y0M0W1D' do
+    past_date = DvDate.new(:value => '2009-12-31')
+    future_date=DvDate.new(:value => '2010-01-01')
+    past_date.diff(future_date).value.should == 'P0Y0M0W1D'
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/date_time/dv_date_time_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require 'openehr/rm/data_types/quantity/date_time'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvDateTime do
+  before(:each) do
+    @dv_date_time = DvDateTime.new(:value => '2009-09-29T15:03:22.3Z')
+  end
+
+  it 'should be an instance of DvDateTime' do
+    @dv_date_time.should be_an_instance_of DvDateTime
+  end
+
+  it 'magnitude should be 63423697018.3' do
+    @dv_date_time.magnitude.should be_within(0.01).of(63423697018.3)
+  end
+
+  it 'should be equal when magnitude is same' do
+    @dv_date_time.should == DvDateTime.new(:value => '2009-09-29T15:03:22.3Z')
+  end
+
+  it 'diff should be caluculated from past to future' do
+    future = DvDateTime.new(:value => '2009-10-29T16:23:30.3Z')
+    @dv_date_time.diff(future).value.should == 'P0Y1M0W0DT1H20M8.0S'
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/date_time/dv_duration_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvDate do
+  before(:each) do
+    @dv_duration = DvDuration.new(:value => 'P1Y2M3W4DT5H6M7.7S')
+  end
+
+  it 'is an instance of DvDuration' do
+    @dv_duration.should be_an_instance_of DvDuration
+  end
+
+  it 'year is 1' do
+    @dv_duration.years.should be 1
+  end
+
+  it 'months is 2' do
+    @dv_duration.months.should be 2
+  end
+
+  it 'weeks is 3' do
+    @dv_duration.weeks.should be 3
+  end
+
+  it 'days is 4' do
+    @dv_duration.days.should be 4
+  end
+
+  it 'hours should be 5' do
+    @dv_duration.hours.should be 5
+  end
+
+  it 'minutes should be 6' do
+    @dv_duration.minutes.should be 6
+  end
+
+  it 'seconds should be 7' do
+    @dv_duration.seconds.should be 7
+  end
+
+  it 'fractional_second should be 0.7' do
+    @dv_duration.fractional_second.should == 0.7
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/date_time/dv_temporal_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+require 'openehr/rm/data_types/quantity/date_time'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvTemporal do
+  before(:each) do
+    @dv_temporal = DvTemporal.new(:value => '2009-09-28T23:36')
+  end
+
+  it 'should be an instance of DvTemporal' do
+    @dv_temporal.should be_an_instance_of DvTemporal
+  end
+
+  it 'should raise ArgumentError with nil value' do
+    lambda {
+      @dv_temporal.value = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty value' do
+    lambda {
+      @dv_temporal.value = ''
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/date_time/dv_time_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvTime do
+  before(:each) do
+    @dv_time = DvTime.new(:value => '11:17:30.2-0900')
+  end
+
+  it 'should be an instance of DvTime' do
+    @dv_time.should be_an_instance_of DvTime
+  end
+
+  it 'hour should be 11' do
+    @dv_time.hour.should == 11
+  end
+
+  it 'minute should be 17' do
+    @dv_time.minute.should == 17
+  end
+
+  it 'second should be 30' do
+    @dv_time.second.should == 30
+  end
+
+  it 'fractional_second should be 0.2' do
+    @dv_time.fractional_second.should == 0.2
+  end
+
+  it 'timezone should be -0900' do
+    @dv_time.timezone.should == '-0900'
+  end
+
+  it 'magnitude should 40650.2' do
+    @dv_time.magnitude.should == 40650.2
+  end
+  
+  it 'should be ' do
+    diff_time = DvTime.new(:value => '15:36:48.05')
+    @dv_time.diff(diff_time).value.should =='P0Y0M0W0DT4H19M17.85S'
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_absolute_quantity_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvAbsoluteQuantity do
+  before(:each) do
+    @dv_absolute_quantity = DvAbsoluteQuantity.new(:magnitude => 7)
+  end
+
+  it 'should be an instance of DvAbsoluteQuantity' do
+    @dv_absolute_quantity.should be_an_instance_of DvAbsoluteQuantity
+  end
+
+  it 's add 3 method should magnitude 10' do
+    dv_absolute_quantity10 =
+      @dv_absolute_quantity.add(DvAbsoluteQuantity.new(:magnitude => 3))
+    dv_absolute_quantity10.magnitude.should == 10
+  end
+
+  it 's diff method should return DvAmount' do    
+    diff_dv_amount = @dv_absolute_quantity.diff(DvAbsoluteQuantity.new(
+                                                    :magnitude => 10))
+    diff_dv_amount.magnitude.should == 3
+  end
+
+  it 's subtract method should raise NotImplementedError' do
+    sub_dv_absolute_quantity = @dv_absolute_quantity.subtract(DvAbsoluteQuantity.new(:magnitude => 10))
+    sub_dv_absolute_quantity.magnitude.should == -3
+  end
+
+  it 'should be raise ArgumentError when type mismatched' do
+    lambda {
+      @dv_absolute_quantity.add(1)
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_amount_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvAmount do
+  before(:each) do
+    @dv_amount = DvAmount.new(:magnitude => 2,
+                              :accuracy => 100,
+                              :accuracy_percent => true)
+  end
+
+  it 'should be an instance of DvAmount' do
+    @dv_amount.should be_an_instance_of DvAmount
+  end
+
+  it 's magnitude should be equal 2' do
+    @dv_amount.magnitude.should be_equal 2
+  end
+
+  it 's accuracy should be 100 percent' do
+    @dv_amount.accuracy.should be_equal 100
+  end
+
+  it 's accuracy_is_percent should be true' do
+    @dv_amount.accuracy_is_percent?.should be_true
+  end
+
+  it 'should has an instance with nil accuracy' do
+    dv_amount = DvAmount.new(:magnitude => 1)
+    dv_amount.should be_an_instance_of DvAmount
+  end
+
+  it 'should be 3 if +2 magnitude DvAmount' do
+    dv_amount4 = @dv_amount + DvAmount.new(:magnitude => 2)
+    dv_amount4.magnitude.should == 4
+  end
+
+  it 'should be -1 if - 3 magnitude DvAmount' do
+    dv_amount_1 = @dv_amount - DvAmount.new(:magnitude => 3)
+    dv_amount_1.magnitude.should == -1
+  end
+
+  it 'should be type mismatch' do
+    lambda {
+      @dv_amount + 1
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(0, true)
+    }.should_not raise_error ArgumentError
+  end
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(50, true)
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(100, true)
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invaild accuracy' do
+    lambda {
+      @dv_amount.set_accuracy(-0.01, true)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invaild accuracy' do
+    lambda {
+      @dv_amount.set_accuracy(100.1, true)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(0, false)
+    }.should_not raise_error ArgumentError
+  end
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(0.5, false)
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError' do
+    lambda {
+      @dv_amount.set_accuracy(1.0, false)
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invaild accuracy' do
+    lambda {
+      @dv_amount.set_accuracy(-0.01, false)
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invaild accuracy' do
+    lambda {
+      @dv_amount.set_accuracy(1.01, false)
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_count_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvCount do
+  before(:each) do
+    @dv_count = DvCount.new(:magnitude => 1)
+  end
+
+  it 'should be an instance of DvCount' do
+    @dv_count.should be_an_instance_of DvCount
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_interval_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvInterval do
+  before(:each) do
+    @dv_interval = DvInterval.new(:upper => 100,
+                                  :lower => 1)
+  end
+
+  it 'should be an instance of DvInterval' do
+    @dv_interval.should be_an_instance_of DvInterval
+  end
+
+  it 's upper should be larger than lower' do
+    @dv_interval.upper.should > @dv_interval.lower
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_ordered_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+include OpenEHR::RM::DataTypes::Text
+
+describe DvOrdered do
+  before(:each) do
+    @dv_ordered = DvOrdered.new
+  end
+
+  it 'should be an instance of DvOrdered' do
+    @dv_ordered.should be_an_instance_of DvOrdered
+  end
+
+  it 'is_normal? should be false' do
+    @dv_ordered.is_normal?.should be_false
+  end
+
+  it 'should be normal' do
+    normal_code = stub(CodePhrase, :code_string => 'N')
+    @dv_ordered.normal_status = normal_code
+    @dv_ordered.is_normal?.should be_true
+  end
+
+  it 'should not be normal' do
+    abnormal_code = stub(CodePhrase, :code_string => 'H')
+    @dv_ordered.normal_status = abnormal_code
+    @dv_ordered.is_normal?.should_not be_true
+  end
+
+  it 'is_simple? should be true' do
+    @dv_ordered.is_simple?.should be_true
+  end
+
+  it 'is_simple? should be false' do
+    @dv_ordered.other_reference_ranges = 'dummy'
+    @dv_ordered.is_simple?.should be_false
+  end
+
+  it 'should raise ArgumentError' do
+    lambda{
+      @dv_ordered.other_reference_ranges = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should be normal in range' do
+    normal_range = stub(DvInterval, :has => true)
+    @dv_ordered.normal_range = normal_range
+    @dv_ordered.is_normal?.should be_true
+  end
+
+  it 'is_strictly_comparable_to should be true for DvOrdered' do
+    @dv_ordered.is_strictly_comparable_to?(DvOrdered.new).should be_true
+  end
+
+  it 'should be raise NotImplemented error' do
+    lambda {
+      @dv_ordered<=>1
+    }.should raise_error(NotImplementedError)
+  end
+end

data/spec/lib/openehr/rm/data_types/quantity/dv_ordinal_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+
+describe DvOrdinal do
+  before(:each) do
+    terminology_id = stub(TerminologyID, :value => 'urine:prot')
+    code_phrase = stub(CodePhrase, :terminology_id => terminology_id)
+    symbol = stub(DvCodedText, :code_string => '+',
+                  :defining_code => code_phrase)
+    dv_text = stub(DvText, :value => 'limits')
+    limits = stub(ReferenceRange, :meaning => dv_text)
+    @dv_ordinal = DvOrdinal.new(:value => 1,
+                                :symbol => symbol,
+                                :limits => limits)
+  end
+
+  it 'should be an instance of DvOrdinal' do
+    @dv_ordinal.should be_an_instance_of DvOrdinal
+  end
+
+  it 's value should be equal 1' do
+    @dv_ordinal.value.should be_equal 1
+  end
+
+  it 's symbol should be + code string' do
+    @dv_ordinal.symbol.code_string.should == '+'
+  end
+
+  it 's symbol defining_code should be urine:prot' do
+    @dv_ordinal.symbol.defining_code.terminology_id.value.should ==
+      'urine:prot'
+  end
+
+  it 'should be strictry comperable to other DvOrdinal' do
+    terminology_id = stub(TerminologyID, :value => 'urine:prot')
+    code_phrase = stub(CodePhrase, :terminology_id => terminology_id)
+    symbol = stub(DvCodedText, :defining_code => code_phrase)
+    dv_ordinal = DvOrdinal.new(:value => 2,
+                               :symbol => symbol)
+    @dv_ordinal.is_strictly_comparable_to?(dv_ordinal).should be_true
+  end
+
+  it 's limit.value should be limits' do
+    @dv_ordinal.limits.meaning.value.should == 'limits'
+  end
+
+  it 'should raise error when limits.value is not limitted' do
+    unlimit = stub(DvText, :value => 'unimitted')
+    unlimitted_range = stub(ReferenceRange, :meaning => unlimit)
+    lambda {
+      @dv_ordinal.limits = unlimitted_range
+    }.should raise_error ArgumentError
+  end
+
+  it 'should be comparable' do
+    dv_ordinal = stub(DvOrdinal, :value => 2)
+    @dv_ordinal.should < dv_ordinal
+  end
+
+  it 'is_strictly comparable should be false with other instance' do
+    @dv_ordinal.is_strictly_comparable_to?('dummy').should be_false
+  end
+
+  it 'is strictly comparable should be false with other terminology' do
+    terminology_id = stub(TerminologyID, :value => 'blood pressure')
+    code_phrase = stub(CodePhrase, :terminology_id => terminology_id)
+    symbol = stub(DvCodedText, :defining_code => code_phrase)
+    dv_ordinal = DvOrdinal.new(:value => 3,
+                               :symbol => symbol)
+    @dv_ordinal.is_strictly_comparable_to?(dv_ordinal).should be_false
+  end
+end