openehr 1.2.8 → 1.2.9

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-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_coded_text_spec.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../spec_helper'
-
-module OpenEHR
-  module RM
-    module DataTypes
-      module Text
-        describe DvCodedText do
-          let(:dv_coded_text) {
-            defining_code = double(CodePhrase)
-            defining_code.stub(:code_string).and_return('Acute myeloid leukemia')
-            DvCodedText.new(value: 'C920', defining_code: defining_code) }
-
-          it "should be_an_instance_of DvCodedText" do
-            dv_coded_text.should be_an_instance_of DvCodedText
-          end
-
-          it 'value should be assigned valid' do
-            dv_coded_text.value.should == 'C920'
-          end
-
-          it 'defining code string is Acute myeloid leukemia' do
-            dv_coded_text.defining_code.code_string.should ==
-              'Acute myeloid leukemia'
-          end
-        end
-      end
-    end
-  end
-end

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

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

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