openehr 1.2.8 → 1.2.9

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

@@ -1,64 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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