openehr 1.2.8 → 1.2.9

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

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

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

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

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

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

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

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

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