open_ehr 0.6.1

data/spec/lib/open_ehr/rm/data_structures/item_structure/item_table_spec.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+def row(args)
+  return args.collect do |n|
+    Element.new(:name => DvText.new(:value => n),
+                :archetype_node_id => 'test')
+  end
+end
+
+def cluster_builder(name,rows)
+  return Cluster.new(:name => DvText.new(:value => name),
+                     :archetype_node_id => 'test',
+                     :items => rows)
+end
+
+describe ItemTable do
+  before(:each) do
+    row1 = row(%w{one two three})
+    row2 = row(%w{four five six})
+    rows = [row1, row2].collect{|r| cluster_builder('cluster',r)}
+    @item_table = ItemTable.new(:name => DvText.new(:value => 'item table'),
+                                :archetype_node_id => 'test',
+                                :rows => rows)
+  end
+
+  it 'should be an instance of ItemTable' do
+    @item_table.should be_an_instance_of ItemTable
+  end
+
+  it 's row count should be 2' do
+    @item_table.row_count.should be_equal 2
+  end
+
+  it 's row_count should be 0 when rows are nil' do
+    @item_table.rows = nil
+    @item_table.row_count.should be_equal 0
+  end
+
+  it 's column_count should be 3' do
+    @item_table.column_count.should be_equal 3
+  end
+
+  it 'column_count should be 0 when @rows == nil' do
+    @item_table.rows = nil
+    @item_table.column_count.should be_equal 0
+  end
+
+  it 's row_names should be cluster cluster' do
+    @item_table.row_names.should == %w{cluster cluster}.collect{|n|
+      DvText.new(:value => n)}
+  end
+
+  it 's row_names should be empty when items are nil' do
+    @item_table.rows = nil
+    @item_table.row_names.should == []
+  end
+
+  it 's column_names should one two three' do
+    @item_table.column_names.should == %w{one two three}.collect{|s|
+      DvText.new(:value => s)}
+  end
+
+  it 's column_names should empty when items aer nil' do
+    @item_table.rows = nil
+    @item_table.column_names.should == []
+  end
+
+  it 's ith_row(integer) should be ith row' do
+    @item_table.ith_row(2).items[1].name.value.should == 'five'
+  end
+
+  it 'should be invalid index under 0' do
+    lambda {@item_table.ith_row(0) }.should raise_error(ArgumentError)
+  end
+
+  it 'should be true because it has_row_with_name cluster' do
+    @item_table.has_row_with_name?('one').should be_true
+  end
+
+  it 'should be true because it does not have_row_with_name key' do
+    @item_table.has_row_with_name?('two').should_not be_true
+  end
+
+  it 'should raise argument error key is nil' do
+    lambda {@item_table.has_row_with_name?(nil)
+      }.should raise_error(ArgumentError)
+  end
+
+  it 'should raise argument error key is empty' do
+    lambda {@item_table.has_row_with_name?('')
+      }.should raise_error(ArgumentError)
+  end
+
+  it 'should be true because it has_column_with_name one' do
+    @item_table.has_column_with_name?('one').should be_true
+  end
+
+  it 'should be false it has_column with name ten' do
+    @item_table.has_column_with_name?('ten').should be_false
+  end
+
+  it 'second row should be named_row four' do
+    @item_table.named_row('four').items[1].name.value = 'five'
+  end
+
+  it 'should be true if row has key' do
+    @item_table.has_row_with_key?(Set['one','two']).should be_true
+  end
+
+  it 'should not be true if row has not key' do
+    @item_table.has_row_with_key?(Set['two','five']).should be_false
+  end
+
+  it 'should be a first row that has one' do
+    @item_table.row_with_key(Set['one', 'two']).items[0].name.value.should =='one'
+  end
+
+  it 'should raise argument error if row has no key' do
+    lambda {
+      @item_table.row_with_key(Set['two','five'])}.should raise_error(ArgumentError)
+  end
+
+  it 'should be element at cell ij' do 
+    @item_table.element_at_cell_ij(2,2).name.value.should == 'five'
+  end
+
+  it 'should not be element at cell with wrong ij' do
+    @item_table.element_at_cell_ij(2,3).name.value.should_not == 'five'
+  end
+
+  it 'should be two element at named cell by row column' do
+    @item_table.element_at_named_cell('cluster', 'three').name.value == 'three'
+  end
+
+  it 'should return nil when rows are nil' do
+    @item_table.rows = nil
+    @item_table.row_count.should be_equal 0
+  end
+
+  it 'should be first row as hierachy' do
+    @item_table.as_hierarchy.name.value.should == 'cluster'
+  end
+end

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

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

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