openehr 1.1.0

data/spec/lib/openehr/rm/common/resource/resource_description_item_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::DataTypes::Text
+
+describe ResourceDescriptionItem do
+  before(:each) do
+    language = stub(CodePhrase, :defining_code => 'ja')
+    original_resource_uri = {'jp' => 'http://openehr.jp/'}
+    @resource_description_item =
+      ResourceDescriptionItem.new(:language => language,
+                                  :purpose => 'test',
+                                  :keywords => ['openehr'],
+                                  :use => 'development',
+                                  :misuse => 'none',
+                                  :copyright => 'Shinji KOBAYASHI',
+                                  :original_resource_uri => original_resource_uri,
+                                  :other_details => {'charset' => 'UTF-8'})
+  end
+
+  it 'should be an instance of ResourceDescriptionItem' do
+    @resource_description_item.should be_an_instance_of ResourceDescriptionItem
+  end
+
+  it 'language should ja' do
+    @resource_description_item.language.defining_code.should == 'ja'
+  end
+
+  it 'purpose should be test' do
+    @resource_description_item.purpose.should == 'test'
+  end
+
+  it 'should raise ArgumentError with nil purpose' do
+    lambda {
+      @resource_description_item.purpose = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty purpose' do
+    lambda {
+      @resource_description_item.purpose = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'keywords should [openehr]' do
+    @resource_description_item.keywords.should == ['openehr']
+  end
+
+  it 'use should be development' do
+    @resource_description_item.use.should == 'development'
+  end
+
+  it 'should raise ArgumentError with use is empty' do
+    lambda {
+      @resource_description_item.use = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil use' do
+    lambda {
+      @resource_description_item.use = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'misuse should be none' do
+    @resource_description_item.misuse.should == 'none'
+  end
+
+  it 'should raise ArgumentError with empty misuse' do
+    lambda {
+      @resource_description_item.misuse = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil misuse' do
+    lambda {
+      @resource_description_item.misuse = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'copyright should be Shinji KOBAYASHI' do
+    @resource_description_item.copyright.should == 'Shinji KOBAYASHI'
+  end
+
+  it 'should raise error with empty copyright' do
+    lambda {
+      @resource_description_item.copyright = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil copyright' do
+    lambda {
+      @resource_description_item.copyright = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'original_resource_uri should {jp, http://openehr.jp/}' do
+    @resource_description_item.original_resource_uri.should ==
+      {'jp' => 'http://openehr.jp/'}
+  end
+
+  it 'other_details should {charset, UTF-8}' do
+    @resource_description_item.other_details.should ==
+      {'charset' => 'UTF-8'}
+  end
+end

data/spec/lib/openehr/rm/common/resource/resource_description_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Resource
+
+describe ResourceDescription do
+  before(:each) do
+    original_author = {'Shinji KOBAYASHI' => 'Ehime University'}
+    other_contributors = ['Akimichi TATSUKAWA']
+    resource_description_item =
+      stub(ResourceDescriptionItem, :purpose => 'test')
+    details = {'case' => resource_description_item}
+    other_details = {'charset' => 'UTF-8'}
+    parent_resource = stub(AuthoredResource, :current_revision => '0.0.3')
+    @resource_description =
+      ResourceDescription.new(:original_author => original_author,
+                              :other_contributors => other_contributors,
+                              :lifecycle_state => 'initial',
+                              :details => details,
+                              :other_details => other_details,
+                              :resource_package_uri => 'http://openehr.jp/',
+                              :parent_resource => parent_resource)
+  end
+
+  it 'should be an instance of ResourceDescription' do
+    @resource_description.should be_an_instance_of ResourceDescription
+  end
+
+  it 'original author should be Shinji KOBAYASHI' do
+    @resource_description.original_author.keys[0].should ==
+      'Shinji KOBAYASHI'
+  end
+
+  it 'other_contributors should be Akimichi TATSUKAWA' do
+    @resource_description.other_contributors[0].should == 
+      'Akimichi TATSUKAWA'
+  end
+
+  it 'lifecycle_state should be initial' do
+    @resource_description.lifecycle_state.should == 'initial'
+  end
+
+  it 'details key should be case' do
+    @resource_description.details.keys[0].should == 'case'
+  end
+
+  it 'other_details value should be charset, UTF-8' do
+    @resource_description.other_details.should == {'charset' => 'UTF-8'}
+  end
+
+  it 'resource package uri should be http://openehr.jp/' do
+    @resource_description.resource_package_uri.should == 'http://openehr.jp/'
+  end
+
+  it 'parent_resource current_revision should be 0.0.3' do
+    @resource_description.parent_resource.current_revision.should == '0.0.3'
+  end
+
+  it 'should raise ArgumentError with nil original author' do
+    lambda {
+      @resource_description.original_author = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil lifecycle_state' do
+    lambda {
+      @resource_description.lifecycle_state = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil details' do
+    lambda {
+      @resource_description.details = {}
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/rm/common/resource/translation_details_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::DataTypes::Text
+
+describe TranslationDetails do
+  before(:each) do
+    language = stub(CodePhrase, :code_string => 'ja')
+    author = Hash['name', 'Shinji KOBAYASHI']
+    @translation_details =
+      TranslationDetails.new(:language => language,
+                             :author => author,
+                             :accreditation => 'Japanese Medical license 333',
+                             :other_details => {'ja' => 'Japanese'})
+  end
+
+  it 'should be an instance of TranslationDetails' do
+    @translation_details.should be_an_instance_of TranslationDetails
+  end
+
+  it 'language should be ja' do
+    @translation_details.language.code_string.should == 'ja'
+  end
+
+  it 'authour should be Shinji KOBAYASHI' do
+    @translation_details.author['name'].should == 'Shinji KOBAYASHI'
+  end
+
+  it 'accreditation should be skoba@moss.gr.jp' do
+    @translation_details.accreditation.should == 'Japanese Medical license 333'
+  end
+
+  it 'other_details should ja, Japanese' do
+    @translation_details.other_details.values[0].should == 'Japanese'
+  end
+end

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

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::Composition
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::Common::Generic
+
+describe Composition do
+  before(:each) do
+    name = DvText.new(:value => 'composition test')
+    language = stub(CodePhrase, :code_string => 'ja')
+    category = stub(DvCodedText, :value => 'event')
+    territory = stub(CodePhrase, :code_string => 'jpn')
+    external_ref = stub(PartyRef, :type =>  'ROLE')
+    composer = stub(PartyProxy, :external_ref => external_ref)
+    content = stub(Array, :size => 3)
+    context = stub(EventContext, :location => 'lab1')
+    @composition = Composition.new(:archetype_node_id => 'at0001',
+                                   :name => name,
+                                   :language => language,
+                                   :category => category,
+                                   :territory => territory,
+                                   :composer => composer,
+                                   :content => content,
+                                   :context => context)
+  end
+
+  it 'should be an instance of Composition' do
+    @composition.should be_an_instance_of Composition
+  end
+
+  it 'language should be assigned properly' do
+    @composition.language.code_string.should == 'ja'
+  end
+
+  it 'should validate language with Termonology service'
+
+  it 'should raise ArgumentError with nil language' do
+    lambda {
+      @composition.language = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'category should be assigned properly' do
+    @composition.category.value.should == 'event'
+  end
+
+  it 'should validate category with Terminology service'
+
+  it 'should raise ArgumentError with nil category' do
+    lambda {
+      @composition.category = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'territory should be assined properly' do
+    @composition.territory.code_string.should == 'jpn'
+  end
+
+  it 'should raise ArgumentError with nil territory' do
+    lambda {
+      @composition.territory = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'composer should be assigned properly' do
+    @composition.composer.external_ref.type.should == 'ROLE'
+  end
+
+  it 'should raise ArgumentError with nil comosser' do
+    lambda {
+      @composition.composer = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'is_persistent? should be false when category is not persistent' do
+    @composition.is_persistent?.should be_false
+  end
+
+  it 'is_persistent? should be true when category is persistent' do
+    category = stub(DvCodedText, :value => 'persistent')
+    @composition.category = category
+    @composition.is_persistent?.should be_true
+  end
+
+  it 'content should be assigned properly' do
+    @composition.content.size.should == 3
+  end
+
+  it 'context should be assigned properly' do
+    @composition.context.location.should == 'lab1'
+  end
+end

data/spec/lib/openehr/rm/composition/content/content_item_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Composition::Content
+include OpenEHR::RM::DataTypes::Text
+
+describe ContentItem do
+  before(:each) do
+    @content_item = ContentItem.new(:name => DvText.new(:value => 'item'),
+                                    :archetype_node_id => 'at0001')
+  end
+
+  it 'should be an instance of ContentItem' do
+    @content_item.should be_an_instance_of ContentItem
+  end
+end

data/spec/lib/openehr/rm/composition/content/entry/action_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataStructures::ItemStructure
+
+describe Action do
+  let(:name) {DvText.new(:value => 'entry package')}
+  let(:language) { double('language',:code_string => 'ja')}
+  let(:encoding) { double('encoding', :code_string => 'UTF-8')}
+  let(:subject) { double('PartyProxy')}
+#  it_should_behave_like 'entry'
+
+  before(:each) do
+    time = DvDateTime.new(:value => '2009-11-18T20:17:18')
+    description = stub(ItemStructure, :archetype_node_id => 'at0002')
+    current_state = stub(DvCodedText, :value => 'planned')
+    ism_transition = stub(IsmTransition, :current_state => current_state)
+    instruction_details = stub(InstructionDetails, :activity_id => 'at0003')
+    @action= Action.new(:archetype_node_id => 'at0001',
+                        :name => name,
+                        :language => language,
+                        :encoding => encoding,
+                        :subject => subject,
+                        :time => time,
+                        :description => description,
+                        :ism_transition => ism_transition,
+                        :instruction_details => instruction_details)
+  end
+
+  it 'should be an instance of Action' do
+    @action.should be_an_instance_of Action
+  end
+
+  it 'time should be assigned properly' do
+    @action.time.value.should == '2009-11-18T20:17:18'
+  end
+
+  it 'should raise ArgumentError with nil assigned to time' do
+    lambda {
+      @action.time = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'description should assigned properly' do
+    @action.description.archetype_node_id.should == 'at0002'
+  end
+
+  it 'should raise ArgumentError with nil description' do
+    lambda {
+      @action.description = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'ism_transition should be assigned properly' do
+    @action.ism_transition.current_state.value.should == 'planned'
+  end
+
+  it 'should raise ArgumentError with nil ism_transition' do
+    lambda {
+      @action.ism_transition = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'instruction_details should be assigned properly' do
+    @action.instruction_details.activity_id.should == 'at0003'
+  end
+end

data/spec/lib/openehr/rm/composition/content/entry/activity_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Encapsulated
+include OpenEHR::RM::DataTypes::Text
+
+describe Activity do
+#  it_should_behave_like 'entry'
+  let(:name) {DvText.new(:value => 'entry package')}
+
+  before(:each) do
+    description = stub(ItemStructure, :archetype_node_id => 'at0002')
+    timing = stub(DvParsable, :value => '2009-11-18T19:35:11')
+    @activity = Activity.new(:archetype_node_id => 'at0001',
+                             :name => name,
+                             :description => description,
+                             :timing => timing,
+                             :action_archetype_id => '/at.+/')
+  end
+
+  it 'should be an instance of Activity' do
+    @activity.should be_an_instance_of Activity
+  end
+
+  it 'description should be assigned properly' do
+    @activity.description.archetype_node_id.should == 'at0002'
+  end
+
+  it 'should raise ArgumentError with nil description' do
+    lambda {
+      @activity.description = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'timing should be assigned properly' do
+    @activity.timing.value.should == '2009-11-18T19:35:11'
+  end
+
+  it 'should raise ArgumentError with nil timing' do
+    lambda {
+      @activity.timing = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'action_archetype_id should be assigned properly' do
+    @activity.action_archetype_id.should == '/at.+/'
+  end
+
+  it 'should raise ArgumentError with nil action_archetype_id' do
+    lambda {
+      @activity.action_archetype_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty action_archetype_id' do
+    lambda {
+      @activity.action_archetype_id = ''
+    }.should raise_error ArgumentError
+  end
+end