openehr 1.1.0

data/spec/lib/openehr/rm/composition/event_context_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::Composition
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataStructures::ItemStructure
+
+describe EventContext do
+  before(:each) do
+    start = DvDateTime.new(:value => '2009-11-13T20:46:57')
+    setting_group = stub(CodePhrase, :code_string => '225')
+    setting = stub(DvCodedText, :defining_code => setting_group)
+    ending = DvDateTime.new(:value => '2010-10-14T09:00:00')
+    participations = stub(Array, :size => 5, :empty? => false)
+    other_context = stub(ItemStructure, :archetype_node_id => 'at0002')
+    @event_context = EventContext.new(:start_time => start,
+                                      :end_time => ending,
+                                      :setting => setting,
+                                      :participations => participations,
+                                      :location => 'ehime',
+                                      :other_context => other_context)
+  end
+
+  it 'should be an instance of EventContext' do
+    @event_context.should be_an_instance_of EventContext
+  end
+
+  it 'start_time should be assigned properly' do
+    @event_context.start_time.value.should == '2009-11-13T20:46:57'
+  end
+
+  it 'should raise ArgumentError with nil start_time' do
+    lambda {
+      @event_context.start_time = nil
+    }.should raise_error ArgumentError
+  end
+  
+  it 'setting should be assigned properly' do
+    @event_context.setting.defining_code.code_string.should == '225'
+  end
+
+  it 'should raise ArgumentError with nil setting' do
+    lambda {
+      @event_context.setting = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should vaildate setting code with Terminology service'
+
+  it 'end_time should be assigned properly' do
+    @event_context.end_time.value.should == '2010-10-14T09:00:00'
+  end
+
+  it 'participations should be properly assigned' do
+    @event_context.participations.size.should be_equal 5
+  end
+
+  it 'should raise ArgumentError with empty participations' do
+    lambda {
+      @event_context.participations = [ ]
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil participations' do
+    lambda {
+      @event_context.participations = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'location should be assigned properly' do
+    @event_context.location.should == 'ehime'
+  end
+
+  it 'should raise ArgumentError with empty location' do
+    lambda {
+      @event_context.location = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil location' do
+    lambda {
+      @event_context.location = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'other_context should be assigned properly' do
+    @event_context.other_context.archetype_node_id.should == 'at0002'
+  end
+end

data/spec/lib/openehr/rm/data_structures/data_structure_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::DataStructures
+include OpenEHR::RM::DataTypes::Text
+
+describe DataStructure do
+  before(:each) do
+    name = DvText.new(:value => 'test')
+    @data_structure = DataStructure.new(:archetype_node_id => 'at0001',
+                                        :name => name)
+  end
+
+  it 'should be an instance of DataStructure' do
+    @data_structure.should be_an_instance_of DataStructure
+  end
+
+  it 'should raise NotImplementedError' do
+    lambda {
+      @data_structure.as_hierarchy
+    }.should raise_error NotImplementedError
+  end
+end

data/spec/lib/openehr/rm/data_structures/history/event_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::History
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe Event do
+  before(:each) do
+    time = DvDateTime.new(:value => '2009-11-12T10:19:33')
+    state = stub(ItemStructure, :archetype_node_id => 'at0002')
+    origin = DvDateTime.new(:value => '2009-11-11T10:20:40')
+    parent = stub(History, :origin => origin)
+    @event = Event.new(:archetype_node_id => 'at0001',
+                       :name => DvText.new(:value => 'Event test'),
+                       :time => time,
+                       :data => 'data',
+                       :state => state,
+                       :parent => parent)
+  end
+
+  it 'should be an instance of Event' do
+    @event.should be_an_instance_of Event
+  end
+
+  it 'data should be assigned properly' do
+    @event.data.should == 'data'
+  end
+
+  it 'time should be assigned properly' do
+    @event.time.value.should == '2009-11-12T10:19:33'
+  end
+
+  it 'state should be assigned properly' do
+    @event.state.archetype_node_id.should == 'at0002'
+  end
+
+  it 'parent should be properly assigned' do
+    @event.parent.origin.value.should == '2009-11-11T10:20:40'
+  end
+
+  it 'offset should be diff of parent.origin from time' do
+    @event.offset.value.should == 'P0Y0M0W0DT23H58M53S'
+  end
+end

data/spec/lib/openehr/rm/data_structures/history/history_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::History
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe History do
+  before(:each) do
+    origin = DvDateTime.new(:value => '2009-11-01T00:00:00')
+    period = DvDuration.new(:value => 'P1Y2M3W4D')
+    duration = DvDuration.new(:value => 'P0Y0M0W6D')
+    events = [stub(Event, :archetype_node_id => 'at0002')]
+    summary = stub(ItemStructure, :archetype_node_id => 'at0003')
+    @history = History.new(:archetype_node_id => 'at0001',
+                           :name => DvText.new(:value => 'history test'),
+                           :origin => origin,
+                           :period => period,
+                           :duration => duration,
+                           :events => events,
+                           :summary => summary)
+  end
+
+  it 'should be an instance of History' do
+    @history.should be_an_instance_of History
+  end
+
+  it 'origin should be properly assigned' do
+    @history.origin.value.should == '2009-11-01T00:00:00'
+  end
+
+  it 'should raise ArgumentError with nil origin' do
+    lambda {
+      @history.origin = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'period should be properly assigned' do
+    @history.period.value.should == 'P1Y2M3W4D'
+  end
+
+  it 'duration should be properly assigned' do
+    @history.duration.value.should == 'P0Y0M0W6D'
+  end
+
+  it 'is_periodic? should be true when period is not nil' do
+    @history.is_periodic?.should be_true
+  end
+
+  it 'is_periodic? should be false when period is nil' do
+    @history.period = nil
+    @history.is_periodic?.should be_false
+  end
+
+  it 'events should be properly assigned' do
+    @history.events[0].archetype_node_id.should == 'at0002'
+  end
+
+  it 'empty events should raise ArgumentError' do
+    lambda {
+      @history.events = []
+    }.should raise_error ArgumentError
+  end
+
+  it 'summary should be properly assigned' do
+    @history.summary.archetype_node_id.should == 'at0003'
+  end
+end

data/spec/lib/openehr/rm/data_structures/history/interval_event_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::History
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe IntervalEvent do
+  before(:each) do
+    time = DvDateTime.new(:value => '2009-11-12T10:19:33Z')
+    state = stub(ItemStructure, :archetype_node_id => 'at0002')
+    origin = DvDateTime.new(:value => '2009-11-11T10:20:40Z')
+    parent = stub(History, :origin => origin)
+    math_function = stub(DvCodedText, :value => 'mean')
+    width = DvDuration.new(:value => 'P0Y2M1W3DT5H7M3S')
+    @interval_event = IntervalEvent.new(:archetype_node_id => 'at0001',
+                                :name => DvText.new(:value => 'Event test'),
+                                :time => time,
+                                :data => 'data',
+                                :width => width,
+                                :math_function => math_function, 
+                                :sample_count => 1234)
+  end
+
+  it 'should be an instance of IntervalEvent' do
+    @interval_event.should be_an_instance_of IntervalEvent
+  end
+
+  it 'width should be assigned properly' do
+    @interval_event.width.value.should == 'P0Y2M1W3DT5H7M3S'
+  end
+
+  it 'math_function should be assigned properly' do
+    @interval_event.math_function.value.should == 'mean'
+  end
+
+  it 'sample_count should be assigned properly' do
+    @interval_event.sample_count.should be_equal 1234
+  end
+
+  it 'should subtract time for interval start time' do
+    @interval_event.interval_start_time.value.should == '2009-09-09T05:12:30Z'
+  end
+end

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

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+describe ItemList do
+  before(:each) do
+    items = %w{one two three}.collect do |n|
+      Element.new(:name => DvText.new(:value => n),
+                  :archetype_node_id => 'test')
+    end
+    item_list_name = DvText.new(:value => 'item list')
+    @item_list = ItemList.new(:name => item_list_name,
+                              :archetype_node_id => 'test',
+                              :items => items)
+    
+  end
+
+  it 'should be instance of ItemList' do
+    @item_list.should be_an_instance_of ItemList
+  end
+
+  it 'count should be 3' do
+    @item_list.item_count.should be_equal 3
+  end
+
+  it 'count should be 0' do
+    @item_list.items = nil
+    @item_list.item_count.should be_equal 0
+  end
+
+
+  it 'retrieve the names of all items' do
+    @item_list.names.should == %w{one two three}.collect{|n|
+      DvText.new(:value => n)}
+  end
+
+  it 'should return the item with a name' do
+    @item_list.named_item('one').name.value.should == 'one'
+  end
+
+  it 'should return nil when item is not exist' do
+    @item_list.named_item('four').should be_nil
+  end
+
+  it 'retrieve the ith item with number' do
+    @item_list.ith_item(1).name.value.should == 'one'
+  end
+
+  it 'generate cluster of items' do
+    @item_list.as_hierarchy.name.value.should == 'item list'
+  end
+end

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

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataStructures::ItemStructure::Representation
+include OpenEHR::RM::DataTypes::Text
+
+describe ItemSingle do
+  before(:each) do
+    element = stub(Element, :archetype_node_id => 'at0002')
+    item_single_name = DvText.new(:value => 'item single')
+    @item_single = ItemSingle.new(:name => item_single_name,
+                                  :archetype_node_id => 'at0001',
+                                  :item => element)
+  end
+
+  it 'should be an instance of ItemSingle' do
+    @item_single.should be_an_instance_of ItemSingle
+  end
+
+  it 'should raise ArgumentError with nil item' do
+    lambda {
+      @item_single.item = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should return as_hierarchy' do
+    @item_single.as_hierarchy.archetype_node_id.should == 'at0002'
+  end
+end

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