open_ehr 0.6.1

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

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe DvDateTime do
+  before(:each) do
+    @dv_date_time = DvDateTime.new(:value => '2009-09-29T15:03:22.3')
+  end
+
+  it 'should be an instance of DvDateTime' do
+    @dv_date_time.should be_an_instance_of DvDateTime
+  end
+
+  it 'magnitude should be 63425495002.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.3')
+  end
+
+  it 'diff should be caluculated from past to future' do
+    future = DvDateTime.new(:value => '2009-10-29T16:23:30.3')
+    @dv_date_time.diff(future).value.should == 'P0Y1M0W0DT1H20M8.0S'
+  end
+end

data/spec/lib/open_ehr/rm/data_types/quantity/date_time/dv_tempral_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+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/open_ehr/rm/data_types/quantity/date_time/dv_time_spec.rb

@@ -0,0 +1,37 @@
+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')
+  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 '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/open_ehr/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/open_ehr/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/open_ehr/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/open_ehr/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/open_ehr/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/open_ehr/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

data/spec/lib/open_ehr/rm/data_types/quantity/dv_proportion_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+include OpenEHR::RM::DataTypes::Quantity::ProportionKind
+
+describe DvProportion do
+  before(:all) do
+    @dv_proportion0 = DvProportion.new(:numerator => 2,
+                                       :denominator => 3,
+                                       :type => PK_RATIO,
+                                       :accuracy => 1,
+                                       :accuracy_percent => true)
+    @dv_proportion1 = DvProportion.new(:numerator => 3,
+                                       :denominator => 1,
+                                       :type => PK_UNITARY)
+    @dv_proportion2 = DvProportion.new(:numerator => 5,
+                                       :denominator => 100,
+                                       :type => PK_PERCENT)
+    @dv_proportion3 = DvProportion.new(:numerator => 7,
+                                       :denominator => 8,
+                                       :type => PK_FRACTION)
+    @dv_proportion4 = DvProportion.new(:numerator => 9,
+                                       :denominator => 10,
+                                       :type => PK_INTEGER_FRACTION)
+  end
+
+  describe 'PK_RATIO type' do
+    it 'should be an instance of DvProportion' do
+      @dv_proportion0.should be_an_instance_of DvProportion
+    end
+
+    it 's numerator should be equal 2' do
+      @dv_proportion0.numerator.should be_equal 2
+    end
+
+    it 's denominator should be equal 3' do
+      @dv_proportion0.denominator.should be_equal 3
+    end
+
+    it 's type should be equal 0' do
+      @dv_proportion0.type.should == 0
+    end
+
+    it 's magnitude should be 2/3' do
+      @dv_proportion0.magnitude.should == 2.0/3.0
+    end
+
+    it 's accuracy should be 1' do
+      @dv_proportion0.accuracy.should == 1
+    end
+
+    it 'is_integral? should be true' do
+      @dv_proportion0.is_integral?.should be_true
+    end
+
+    it 'should be comperable to same type DvProportion' do
+      dv_propotion_type = DvProportion.new(:numerator => 3,
+                                           :denominator => 4,
+                                           :type => 0)
+      @dv_proportion0.is_strictly_comparable_to?(dv_propotion_type).
+        should be_true
+    end
+
+    it 'should not be comparable to other type DvPropotion' do
+      @dv_proportion0.is_strictly_comparable_to?(@dv_proportion1).
+        should_not be_true
+    end
+
+    it 'should not be comperable to other class' do
+      @dv_proportion0.is_strictly_comparable_to?(1).
+        should_not be_true
+    end
+
+    it 'should raise ArguentError with invalid type -1' do
+      lambda {
+        @dv_proportion0.type = -1
+      }.should raise_error ArgumentError
+    end
+
+    it 'should raise ArgumentError with invalid type 5' do
+      lambda {
+        @dv_proportion0.type = 5
+      }.should raise_error ArgumentError
+    end
+
+    it 's precision should be 0' do
+      @dv_proportion0.precision = 0
+      @dv_proportion0.precision.should == 0
+    end
+
+    it 'should raise ArgumentError when is_integral? and precision !=0' do
+      lambda {@dv_proportion0.precision = 1}.should raise_error ArgumentError
+    end
+
+    it 'shoud not raise ArgumentError when is_not ntegral' do
+      @dv_proportion0.numerator = 2.5
+      lambda {
+        @dv_proportion0.precision = 1
+      }.should_not raise_error ArgumentError
+    end
+  end
+
+  describe 'PK_UNITARY type' do
+    it 'should be an instance of DvPropotion' do
+      @dv_proportion1.should be_an_instance_of DvProportion
+    end
+
+    it 'should raise ArgumentError without denominator 1' do
+      lambda {
+        @dv_proportion1.denominator = 10
+      }.should raise_error ArgumentError
+    end
+  end
+
+  describe 'PK_PERCENT type' do
+    it 'should be an instance of DvProportion' do
+      @dv_proportion2.should be_an_instance_of DvProportion
+    end
+
+    it 'should raise ArgumentError without denominator 100' do
+      lambda {
+        @dv_proportion2.denominator = 101
+      }.should raise_error ArgumentError
+    end
+  end
+
+  describe 'PK_FRACTION type' do
+    it 'should be an instance of DvProportion' do
+      @dv_proportion3.should be_an_instance_of DvProportion
+    end
+
+    it 'should raise ArgumentError with fractional denominator' do
+      lambda {
+        @dv_proportion3.denominator = 0.5
+      }.should raise_error ArgumentError
+    end
+
+    it 'should raise ArgumentError with fractional numerator' do
+      lambda {
+        @dv_proportion3.numerator = 0.5
+      }.should raise_error ArgumentError
+    end
+  end
+
+  describe 'PK_FRACTION_INTEGER type' do
+    it 'should be an instance of DvProportion' do
+      @dv_proportion4.should be_an_instance_of DvProportion
+    end
+
+    it 'should raise ArgumentError with fractional denominator' do
+      lambda {
+        @dv_proportion4.denominator = 0.5
+      }.should raise_error ArgumentError
+
+    end
+
+    it 'should raise ArgumentError with fractional numerator' do
+      lambda {
+        @dv_proportion4.numerator = 0.5
+      }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/lib/open_ehr/rm/data_types/quantity/dv_quantified_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvQuantified do
+  before(:all) do
+    @dv_quantified = DvQuantified.new(:magnitude => 1,
+                                      :magnitude_status => '=')
+  end
+
+  it 'should be an instance of DvQuantified' do
+    @dv_quantified.should be_an_instance_of DvQuantified
+  end
+
+  it 's magnitude should be 1' do
+    @dv_quantified.magnitude.should be_equal 1
+  end
+
+  it 's magnitude_status should be =' do
+    @dv_quantified.magnitude_status.should == '='
+  end
+
+  it 's comparable to other DvQuantified' do
+    dv_quantified = DvQuantified.new(:magnitude => 2)
+    @dv_quantified.should < dv_quantified
+  end
+
+  it 'should raise ArgumentError with invalid magnitude_status' do
+    lambda {
+      @dv_quantified.magnitude_status = '+'
+    }.should raise_error ArgumentError
+  end
+
+  it 's accuracy should be unknown' do
+    @dv_quantified.should be_accuracy_unknown
+  end
+end

data/spec/lib/open_ehr/rm/data_types/quantity/dv_quantity_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe DvQuantity do
+  before(:each) do
+    @dv_quantity = DvQuantity.new(:magnitude => 3,
+                                  :units => 'mg',
+                                  :precision => 0)
+  end
+
+  it 'should be an instance of DvQuantity' do
+    @dv_quantity.should be_instance_of DvQuantity
+  end
+
+  it 's units should be mg' do
+    @dv_quantity.units.should == 'mg'
+  end
+
+  describe 'Mathematical Operation' do
+    before(:each) do
+      @dv_quantity5 = DvQuantity.new(:magnitude => 5,
+                                     :units => 'mg')
+    end
+    
+    it 'should be comparable to 5mg' do
+      @dv_quantity.is_strictly_comparable_to?(@dv_quantity5).should be_true
+    end
+
+    it 'should be 8mg added 5mg' do
+      dv_quantity = @dv_quantity + @dv_quantity5
+      dv_quantity.magnitude.should == 8
+    end
+
+    it 'should be -2mg minus 5mg' do
+      dv_quantity = @dv_quantity - @dv_quantity5
+      dv_quantity.magnitude.should == -2
+    end
+
+    it 's unit should be mg' do
+      (@dv_quantity + @dv_quantity5).units.should == 'mg'
+    end
+  end
+
+  it 'should not be comparable to 8km' do
+    dv_quantity = DvQuantity.new(:magnitude => 8,
+                                 :units => 'km')
+    @dv_quantity.is_strictly_comparable_to?(dv_quantity).should_not be_true
+  end
+
+  it 'should return false with other type' do
+    @dv_quantity.is_strictly_comparable_to?(1).should_not be_true
+  end
+
+  it 's precision should be equal 0' do
+    @dv_quantity.precision.should == 0
+  end
+
+  it 'should be integral' do
+    @dv_quantity.is_integral?.should be_true
+  end
+
+  it 'should not be integral do' do
+    @dv_quantity.precision = 3
+    @dv_quantity.is_integral?.should_not be_true
+  end
+
+  it 'should not raise ArgumentError with -1 precision' do
+    lambda {
+      @dv_quantity.precision = -1
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with -2 precision' do
+    lambda {
+      @dv_quantity.precision = -2
+    }.should raise_error ArgumentError
+  end
+end