openehr 1.2.8 → 1.2.9

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

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-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 not be terminal * another expression' do
-    @dv_state.should_not be_terminal
-  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

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

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

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