openehr 1.1.0

data/spec/lib/openehr/rm/data_structures/item_structure/item_tree_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+describe ItemTree do
+  before(:each) do
+    i = 1
+    items = %w{one two three}.collect do |name|
+      i += 1
+      Element.new(:name => DvText.new(:value => name),
+                  :archetype_node_id => 'at000' + i.to_s)
+    end
+    name = DvText.new(:value => 'item tree')
+    @item_tree = ItemTree.new(:name => name,
+                              :archetype_node_id => 'at0001',
+                              :items => items)
+  end
+
+  it 'should be an instance of ItemTree' do
+    @item_tree.should be_an_instance_of ItemTree
+  end
+
+  it 'first item name should be one' do
+    @item_tree.items[0].name.value.should == 'one'
+  end
+
+  it 'has valid element path' do
+    @item_tree.has_element_path?('at0002').should be_true
+  end
+
+  it 'should return false with wrong node' do
+    @item_tree.has_element_path?('at0005').should be_false
+  end
+
+  it 'path at002 should return two' do
+    @item_tree.element_at_path('at0003').name.value.should == 'two'
+  end
+
+  it 'path at005 should return nil' do
+    @item_tree.element_at_path('at0005').should be_nil
+  end
+
+  it 'should returns ItemTree as Cluster' do
+    @item_tree.as_hierarchy.name.value.should == 'item tree'
+  end
+end

data/spec/lib/openehr/rm/data_structures/item_structure/representation/cluster_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+describe Cluster do
+  before(:each) do
+    item = stub(Item)
+    @cluster = Cluster.new(:archetype_node_id => 'at0001',
+                           :name => DvText.new(:value => 'cluster'),
+                           :items => [item, item])
+  end
+
+  it 'should be an isntance of Cluster' do
+    @cluster.should be_an_instance_of Cluster
+  end
+
+  it 'item size should be 2' do
+    @cluster.items.size.should == 2
+  end
+
+  it 'should raise ArgumentError with empty items' do
+    lambda {
+      @cluster.items = []
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/data_structures/item_structure/representation/element_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+describe Element do
+  before(:each) do
+    value = DvText.new(:value => 'test')
+    @element = Element.new(:archetype_node_id => 'at0001',
+                           :name => DvText.new(:value => 'element'),
+                           :value => value)
+  end
+
+  it 'should be an instance of Element' do
+    @element.should be_an_instance_of Element
+  end
+
+  it 'value should be assigned as test' do
+    @element.value.value.should == 'test'
+  end
+
+  it 'nullflavor should be assigned'
+end

data/spec/lib/openehr/rm/data_types/basic/data_value_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+
+include OpenEHR::RM::DataTypes::Basic
+
+describe DataValue do
+  before(:each) do
+    @data_value = DataValue.new(:value => 'ANY')
+  end
+
+  it 'should be an instance of DataValue' do
+    @data_value.should be_an_instance_of DataValue
+  end
+
+  it 's value should be stub' do
+    @data_value.value.should == 'ANY'
+  end
+end

data/spec/lib/openehr/rm/data_types/basic/dv_boolean_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Basic
+
+
+describe DvBoolean do
+  before(:each) do
+    @dv_boolean = DvBoolean.new(:value => "TRUE")
+  end
+
+  it 'should be an instance of DvBoolean' do
+    @dv_boolean.should be_an_instance_of DvBoolean
+  end
+
+  it 'should be true' do
+    @dv_boolean.value.should be_true
+    @dv_boolean.value?.should be_true
+  end
+
+  it 's value assigned false, then it should not be false' do
+    @dv_boolean.value = false
+    @dv_boolean.value.should_not be_true
+  end
+
+  it 'raise ArgumentError' do
+    lambda {
+      @dv_boolean.value = nil
+    }.should raise_error(ArgumentError)
+  end
+end

data/spec/lib/openehr/rm/data_types/basic/dv_identifier_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Basic
+include OpenEHR::RM::DataTypes::Text
+
+describe DvIdentifier do
+  before(:each) do
+    @dv_identifier = DvIdentifier.new(:issuer => 'Ruby Hospital',
+                                      :assigner => 'Information office',
+                                      :id => '0123456-0',
+                                      :type =>'personal id')
+  end
+
+  it 'should be an instance of DvIdentifier' do
+    @dv_identifier.should be_an_instance_of DvIdentifier
+  end
+
+  it 's issuer should be Ruby hospital' do
+    @dv_identifier.issuer.should == 'Ruby Hospital'
+  end
+
+  it 's assigner should be Information office' do
+    @dv_identifier.assigner.should == 'Information office'
+  end
+
+  it 's id should be 0123456-0' do
+    @dv_identifier.id.should == '0123456-0'
+  end
+
+  it 's type should be personal id' do
+    @dv_identifier.type.should == 'personal id'
+  end
+
+  it 's issuer should be change to other hospital' do
+    lambda {
+      @dv_identifier.issuer = 'Other Hospital'
+    }.should change(@dv_identifier, :issuer).
+      from('Ruby Hospital').to('Other Hospital')
+  end
+
+  it 'raise ArgumentError for nil issuer' do
+    lambda {
+      @dv_identifier.issuer = nil
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'raise ArgumentError for empty issuer' do
+    lambda {
+      @dv_identifier.issuer = ''
+    }.should raise_error(ArgumentError)
+  end
+
+  it 's assigner should change from Information office to Service office' do
+    lambda {
+      @dv_identifier.assigner = 'Service office'
+    }.should change{@dv_identifier.assigner}.
+      from('Information office').to('Service office')
+  end
+
+  it 'raise ArgumentError for nil assigner' do
+    lambda {
+      @dv_identifier.assigner = nil
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'raise ArgumentError for empty assigner' do
+    lambda {
+      @dv_identifier.assigner = ''
+    }.should raise_error(ArgumentError)
+  end
+
+  it 's id should change from 0123456-0 to TEST-0987' do
+    lambda {
+      @dv_identifier.id = 'TEST-0987'
+    }.should change(@dv_identifier, :id).
+      from('0123456-0').to('TEST-0987')
+  end
+
+  it 'raise ArgumentError for nil id' do
+    lambda {
+      @dv_identifier.id = nil
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'raise ArgumentError for empty id' do
+    lambda {
+      @dv_identifier.id = ''
+    }.should raise_error(ArgumentError)
+  end
+
+  it 's type should change form personal id to test id' do
+    lambda {
+      @dv_identifier.type = "test id"
+    }.should change(@dv_identifier, :type).
+      from('personal id').to('test id')
+  end
+
+  it 'raise ArgumentError for nil type' do
+    lambda {
+      @dv_identifier.type = nil
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'raise ArgumentError for empty issuer' do
+    lambda {
+      @dv_identifier.type = ''
+    }.should raise_error(ArgumentError)
+  end
+end

data/spec/lib/openehr/rm/data_types/basic/dv_state_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Basic
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Text
+
+describe DvState do
+  before(:each) do
+    @terminology_id = TerminologyID.new(:value => 'openher')
+    code_phrase = CodePhrase.new(:code_string => '524',
+                                 :terminology_id => @terminology_id)
+    dv_coded_text = DvCodedText.new(:value => "initial",
+                                    :defining_code => code_phrase)
+    @dv_state = DvState.new(:value => dv_coded_text,
+                            :is_terminal => false)
+  end
+
+  it 'should be an instance of DvState' do
+    @dv_state.should be_an_instance_of DvState
+  end
+
+  it 's value should be initial' do
+    @dv_state.value.value.should == 'initial'
+  end
+
+  it 'should change other value assigned' do
+    code_phrase = CodePhrase.new(:code_string => '526',
+                                 :terminology_id => @terminology_id)
+    dv_coded_text = DvCodedText.new(:value =>'planned',
+                                    :defining_code => code_phrase)
+    lambda {
+      @dv_state.value = dv_coded_text
+    }.should change{@dv_state.value.value}.from('initial').to('planned')
+  end
+
+  it 'is not terminal' do
+    @dv_state.is_terminal?.should be_false
+  end
+
+  it 'should change to terminal' do
+    lambda {
+      @dv_state.is_terminal = true
+    }.should change(@dv_state, :is_terminal?).from(false).to(true)
+  end
+end

data/spec/lib/openehr/rm/data_types/encapsulated/dv_encapsulated_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Encapsulated
+include OpenEHR::RM::DataTypes::Text
+
+describe DvEncapsulated do
+  before(:each) do
+    dummy = 'test'
+    charset = stub(CodePhrase, :code_string => 'UTF-8')
+    language = stub(CodePhrase, :code_string => 'ja')
+    @dv_encapsulated = DvEncapsulated.new(:value => dummy,
+                                          :charset => charset,
+                                          :language => language)
+  end
+
+  it 's value should be test' do
+    @dv_encapsulated.value.should == 'test'
+  end
+
+  it 's size should be 4' do
+    @dv_encapsulated.size.should be_equal 4
+  end
+
+  it 's charset should be utf-8' do
+    @dv_encapsulated.charset.code_string.should == 'UTF-8'
+  end
+
+  it 's langage should be ja' do
+    @dv_encapsulated.language.code_string.should == 'ja'
+  end
+
+  it 'should raise ArgumentError when language is invalid' do
+    wrong_lang = stub(CodePhrase, :code_string => 'jj')
+    lambda {@dv_encapsulated.language = wrong_lang}.
+      should raise_error(ArgumentError)
+  end
+
+  it 'should raise ArgumentError when charset is invalid' do
+    wrong_charset = stub(CodePhrase, :code_string => 'UBK')
+    lambda {@dv_encapsulated.charset = wrong_charset}.
+      should raise_error(ArgumentError)
+  end
+end

data/spec/lib/openehr/rm/data_types/encapsulated/dv_multimedia_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Encapsulated
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::URI
+include OpenEHR::RM::Support::Identification
+
+describe DvMultimedia do
+  before(:each) do
+    media_type = stub(CodePhrase, :code_string => 'text/xml')
+    charset = stub(CodePhrase, :code_string => 'UTF-8')
+    uri = stub(DvUri, :value => 'http://openehr.jp/')
+    data = Array['123412', '123112']
+    compression_algorithm = stub(CodePhrase, :code_string => 'gzip')
+    integrity_check = Array['123456789ABCDEF','DEADBEEF']
+    integrity_check_algorithm = stub(CodePhrase, :code_string => 'SHA-1')
+    alternate_text = 'test'
+    @dv_multimedia = DvMultimedia.new(:value => '<xml>test</xml>',
+                                      :media_type => media_type,
+                                      :charset => charset,
+                                      :uri => uri,
+                                      :data => data,
+                                      :compression_algorithm => compression_algorithm,
+                                      :integrity_check => integrity_check,
+                                      :integrity_check_algorithm => integrity_check_algorithm,
+                                      :alternate_text => alternate_text)
+  end
+
+  it 'should be an instance of DvMultimedia' do
+    @dv_multimedia.should be_an_instance_of DvMultimedia
+  end
+
+  it 's value should be <xml>test</xml>' do
+    @dv_multimedia.value.should == '<xml>test</xml>'
+  end
+
+  it 's media_type should be text/xml' do
+    @dv_multimedia.media_type.code_string.should == 'text/xml'
+  end
+
+  it 's size should be equal 15' do
+    @dv_multimedia.size.should be_equal 15
+  end
+
+  it 's charset should be UTF-8' do
+    @dv_multimedia.charset.code_string.should == 'UTF-8'
+  end
+
+  it 's uri value should be http://openehr.jp/ ' do
+    @dv_multimedia.uri.value.should == 'http://openehr.jp/'
+  end
+
+  it 's data[0] should be 123412' do
+    @dv_multimedia.data[0].should == '123412'
+  end
+
+  it 's compression_algorithm should be gzip' do
+    @dv_multimedia.compression_algorithm.code_string.should == 'gzip'
+  end
+
+  it 's integrity_check[1] should be DEADBEEF' do
+    @dv_multimedia.integrity_check[1].should == 'DEADBEEF'
+  end
+
+  it 's integrity_check_algorithm should be SHA-1' do
+    @dv_multimedia.integrity_check_algorithm.code_string.should == 'SHA-1'
+  end
+
+  it 's alternate text should be test' do
+    @dv_multimedia.alternate_text.should == 'test'
+  end
+
+  it 'has_integrity_check should be true'
+
+  it 'is compressed should be true'
+
+  it 'is_external should be true'
+
+  it 'is_internal should be false'
+end

data/spec/lib/openehr/rm/data_types/encapsulated/dv_parsable_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataTypes::Encapsulated
+include OpenEHR::RM::DataTypes::Text
+
+describe DvParsable do
+  before(:each) do
+    @dv_parsable = DvParsable.new(:value => 'test',
+                                  :formalism => 'plain/text')
+  end
+
+  it 'should be an instance of DvParsable' do
+    @dv_parsable.should be_an_instance_of DvParsable
+  end
+
+  it 'value should be test' do
+    @dv_parsable.value.should == 'test'
+  end
+
+  it 's size should be 4' do
+    @dv_parsable.size.should be_equal 4
+  end
+
+  it 's formalism should be plain/text' do
+    @dv_parsable.formalism.should == 'plain/text'
+  end
+
+  it 'should raise ArgumentError formalism nil' do
+    lambda {@dv_parsable.formalism = nil}.should raise_error(ArgumentError)
+  end
+
+  it 'should raise ArgumentError formalism empty' do
+    lambda {@dv_parsable.formalism = ''}.should raise_error(ArgumentError)
+  end
+end