open_ehr 0.6.1

data/spec/lib/open_ehr/rm/common/resource/authored_resource_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::Common::ChangeControl
+include OpenEHR::RM::DataTypes::Text
+
+describe AuthoredResource do
+  before(:each) do
+    original_language = stub(CodePhrase, :code_string => 'ja')
+    translation_language = stub(CodePhrase, :code_string => 'en')
+    translation_details = stub(TranslationDetails,
+                               :language => translation_language)
+    translations = Hash['en', translation_details]
+    description = stub(ResourceDescription, :lifecycle_state => 'initial')
+    revision_history = stub(RevisionHistory, :most_recent_version => '0.0.3')
+    languages_available = Set.new %w(ja en)
+    @authored_resource = AuthoredResource.new(
+                  :original_language => original_language,
+                  :translations => translations,
+                  :description => description,
+                  :revision_history => revision_history)
+  end
+
+  it 'should be an instance of AuthoredResource' do
+    @authored_resource.should be_an_instance_of AuthoredResource
+  end
+
+  it 'original language should be ja' do
+    @authored_resource.original_language.code_string.should == 'ja'
+  end
+
+  it 'translations hash en returns en detail' do
+    @authored_resource.translations['en'].language.code_string.should == 'en'
+  end
+
+  it 'description lifecycle_state should e initial' do
+    @authored_resource.description.lifecycle_state.should == 'initial'
+  end
+
+  it 'language_available should be Set(%(ja en))' do
+    languages_set = Set.new ['ja', 'en']
+    @authored_resource.languages_available.should == languages_set
+  end
+
+  it 'current_revision should be 0.0.3' do
+    @authored_resource.current_revision.should == '0.0.3'
+  end
+
+  it 'should be controlled' do
+    @authored_resource.is_controlled?.should be_true
+  end
+
+  it 'should not be controlled' do
+    @authored_resource.revision_history = nil
+    @authored_resource.is_controlled?.should be_false
+  end
+
+  it 'should raise ArgumentError with empty translations' do
+    lambda {
+      @authored_resource.translations = Array.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when original language is nil' do
+    lambda {
+      @authored_resource.original_language = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/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/open_ehr/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/open_ehr/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['Shinji KOBAYASHI', 'Ehime University']
+    @translation_details =
+      TranslationDetails.new(:language => language,
+                             :author => author,
+                             :accreditation => 'skoba@moss.gr.jp',
+                             :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.keys[0].should == 'Shinji KOBAYASHI'
+  end
+
+  it 'accreditation should be skoba@moss.gr.jp' do
+    @translation_details.accreditation.should == 'skoba@moss.gr.jp'
+  end
+
+  it 'other_details should ja, Japanese' do
+    @translation_details.other_details.values[0].should == 'Japanese'
+  end
+end

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

data/spec/lib/open_ehr/rm/composition/content/entry/admin_entry_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::DataStructures::ItemStructure
+
+describe AdminEntry 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
+    data = stub(ItemStructure, :archetype_node_id => 'at0002')
+    @admin_entry = AdminEntry.new(:archetype_node_id => 'at0001',
+                                  :name => DvText.new(:value => 'admin entry'),
+                                  :language => language,
+                                  :encoding => encoding,
+                                  :subject => subject,
+                                  :data => data)
+  end
+
+  it 'should be an instance of AdminEntry' do
+    @admin_entry.should be_an_instance_of AdminEntry
+  end
+
+  it 'data should be assigned properly' do
+    @admin_entry.data.archetype_node_id.should == 'at0002'
+  end
+
+  it 'should raise ArgumentError when nil assigned to data' do
+    lambda {
+      @admin_entry.data = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/composition/content/entry/care_entry_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::Support::Identification
+
+describe CareEntry do
+  let(:language) { double('language',:code_string => 'ja')}
+  let(:encoding) { double('encoding', :code_string => 'UTF-8')}
+  let(:subject) { double('PartyProxy')}
+
+  before(:each) do
+    protocol = stub(ItemStructure, :archetype_node_id => 'at0003')
+    guideline_id = stub(ObjectRef, :type => 'care guideline')
+    @care_entry = CareEntry.new(:archetype_node_id => 'at0001',
+                                :name => DvText.new(:value => 'care entry'),
+                                :language => language,
+                                :encoding => encoding,
+                                :subject => subject,
+                                :protocol => protocol,
+                                :guideline_id => guideline_id)
+  end
+
+  it 'should be an instance of CareEntry' do
+    @care_entry.should be_an_instance_of CareEntry
+  end
+
+  it 'protocol should be assigned properly' do
+    @care_entry.protocol.archetype_node_id.should == 'at0003'
+  end
+
+  it 'guideline should be assined properly' do
+    @care_entry.guideline_id.type.should == 'care guideline'
+  end
+end
+

data/spec/lib/open_ehr/rm/composition/content/entry/entry_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Common::Generic
+
+describe Entry 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')}
+
+  before(:each) do
+    external_ref = stub(PartyRef, :type => 'entry')
+    subject = PartyProxy.new(:external_ref => external_ref)
+    provider_external_ref = stub(PartyRef, :type => 'provider')
+    provider = PartyProxy.new(:external_ref => provider_external_ref)
+    other_participations = stub(Array, :size => 3, :empty? => false)
+    workflow_id = stub(ObjectRef, :type => 'workflow')
+    @entry = Entry.new(:archetype_node_id => 'at0001',
+                       :name => DvText.new(:value => 'entry test'),
+                       :language => language,
+                       :encoding => encoding,
+                       :subject => subject,
+                       :provider => provider,
+                       :other_participations => other_participations,
+                       :workflow_id => workflow_id)
+  end
+
+  it 'should be an instance of Entry' do
+    @entry.should be_an_instance_of Entry
+  end
+
+  it 'language should be assigned properly' do
+    @entry.language.code_string.should == 'ja'
+  end
+
+  it 'should raise ArgumentError when nil assign to language' do
+    lambda {
+      @entry.language = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invalid language code'
+
+  it 'encoding should be assigned properly' do
+    @entry.encoding.code_string.should == 'UTF-8'
+  end
+
+  it 'should raise ArgumentError when nil assign to encoding' do
+    lambda {
+      @entry.encoding = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invalid encoding'
+
+  it 'subject should be assigned properly' do
+    @entry.subject.external_ref.type.should == 'entry'
+  end
+
+  it 'should raise ArgumentError when nil assigned to subject' do
+    lambda {
+      @entry.subject = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'provider should be assigned properly' do
+    @entry.provider.external_ref.type.should == 'provider'
+  end
+
+  it 'other_participations should be assigned properly' do
+    @entry.other_participations.size.should be_equal 3
+  end
+
+  it 'workflow_id should assigned properly' do
+    @entry.workflow_id.type.should == 'workflow'
+  end
+
+  it 'subject_is_self? should be determined by subject class' do
+    @entry.subject_is_self?.should be_false
+  end
+
+  it 'subject_is_self? should be true when subject is instance of PartySelf' do
+    @entry.subject = PartySelf.new
+    @entry.subject_is_self?.should be_true
+  end
+end