openehr 1.1.0

data/spec/lib/openehr/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/openehr/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/openehr/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

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

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe ProportionKind do
+  it 'should be valid proportion kind 0' do
+    ProportionKind.should be_valid_proportion_kind 0
+  end
+
+  it 'should be valid proportion kind 2' do
+    ProportionKind.should be_valid_proportion_kind 2
+  end
+
+  it 'should be valid proportionkind 4' do
+    ProportionKind.should be_valid_proportion_kind 4
+  end
+
+  it 'should not be valid proportionkind -1' do
+    ProportionKind.should_not be_valid_proportion_kind -1
+  end
+
+  it 'should not be valid proportionkind 5' do
+    ProportionKind.should_not be_valid_proportion_kind 5
+  end
+end

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

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Quantity
+
+describe ReferenceRange do
+  before(:each) do
+    dv_interval ||= stub(DvInterval)
+    @mock_dv_interval ||= mock('dv_interval')
+    @reference_range = ReferenceRange.new(:meaning => 'test',
+                                          :range => dv_interval)
+  end
+
+  it 'should be an instance of DvInterval' do
+    @reference_range.should be_an_instance_of ReferenceRange
+  end
+
+  it 's meaning should be test' do
+    @reference_range.meaning.should == 'test'
+  end
+
+  it 'should be in range' do
+    @mock_dv_interval.should_receive(:has?).with(1).and_return(true)
+    @reference_range.range = @mock_dv_interval
+    @reference_range.is_in_range?(1).should be_true
+  end
+
+  it 'should be out of range' do
+    @mock_dv_interval.should_receive(:has?).with(-1).and_return(false)
+    @reference_range.range = @mock_dv_interval
+    @reference_range.is_in_range?(-1).should be_false
+  end
+
+  it 'should raise ArgumentError with nil meaning' do
+    lambda {
+      @reference_range.meaning = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil range' do
+    lambda {
+      @reference_range.range = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/data_types/text/code_phrase_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+
+describe CodePhrase do
+  before(:each) do
+    terminology_id = TerminologyID.new(:value => 'openehr')
+    @code_phrase = CodePhrase.new(:code_string => '535',
+                                  :terminology_id => terminology_id)
+  end
+
+  it 'should be an instance of CodePhrase' do
+    @code_phrase.should be_an_instance_of CodePhrase
+  end
+
+  it 's code_string should be 535' do
+    @code_phrase.code_string.should == '535'
+  end
+
+  it 's terminology_id.name should be openehr' do
+    @code_phrase.terminology_id.name.should == 'openehr'
+  end
+end

data/spec/lib/openehr/rm/data_types/text/dv_paragraph_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Text
+
+describe DvParagraph do
+  before(:each) do
+    items_dummy = Array[1,2]
+    @dv_paragraph = DvParagraph.new(:items => items_dummy)
+  end
+
+  it 's items should be_size 2' do
+    @dv_paragraph.items.size.should be_equal 2
+  end
+end

data/spec/lib/openehr/rm/data_types/text/dv_text_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::URI
+
+describe DvText do
+  before(:each) do
+    terminology_id = TerminologyID.new(:value => 'openehr')
+    language = CodePhrase.new(:terminology_id => terminology_id,
+                              :code_string => 'ja')
+    encoding = CodePhrase.new(:terminology_id => terminology_id,
+                              :code_string => 'utf-8')
+    term = stub(CodePhrase, :code_string => 'C92')
+    term_mapping = stub(TermMapping, :target => term)
+    hyperlink = stub(DvUri, :value => 'http://openehr.jp/ruby')
+    @dv_text = DvText.new(:value => 'test',
+                          :formatting => 'font = 12pt',
+                          :language => language,
+                          :encoding => encoding,
+                          :mappings => [term_mapping],
+                          :hyperlink => hyperlink)
+  end
+
+  it 'should be an instance of DvText' do
+    @dv_text.should be_an_instance_of DvText
+  end
+
+  it 's value should be test' do
+    @dv_text.value.should == 'test'
+  end
+
+  it 'should raise ArgumentError, when value include \n' do
+    lambda {
+      @dv_text.value = "not valid value\n"
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'should raise ArgumentError, when value is nil' do
+    lambda {
+      @dv_text.value = nil
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'formatting should be font' do
+    @dv_text.formatting.should == 'font = 12pt'
+  end
+
+  it 'should raise ArgumentError, when formatting is empty' do
+    lambda{@dv_text.formatting = ""}.should raise_error(ArgumentError)
+  end
+
+  it 'has 1 mapping' do
+    @dv_text.mappings.size.should be 1
+  end
+
+  it '1st item of mappings is C92' do
+    @dv_text.mappings[0].target.code_string.should == 'C92'
+  end
+
+  it 'raise error if mappings are empty' do
+    expect {@dv_text.mappings = Array.new}.to raise_error
+  end
+
+  it 'does not raise error if mappings are nil' do
+    expect {@dv_text.mappings = nil}.not_to raise_error
+  end
+
+  it 'hyperlink is http://openehr.jp/ruby' do
+    @dv_text.hyperlink.value.should == 'http://openehr.jp/ruby'
+  end
+
+  it 's language code_string should be ja' do
+    @dv_text.language.code_string.should == 'ja'
+  end
+
+  it 's encoding should be utf-8' do
+    @dv_text.encoding.code_string.should == 'utf-8'
+  end
+end