openehr 1.1.0

data/spec/lib/openehr/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/openehr/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/openehr/rm/composition/content/entry/entry_spec.rb

@@ -0,0 +1,98 @@
+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' do
+    terminology_id = TerminologyID.new(:value => 'ISO639-1')
+    invalid_language = CodePhrase.new(:code_string => 'jj',
+                                      :terminology_id => terminology_id)
+    expect {@entry.language = invalid_language}.to raise_error ArgumentError
+  end
+
+  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' do
+    terminology_id = TerminologyID.new(:value => 'ISO639-1')
+    invalid_encoding = CodePhrase.new(:terminology_id => terminology_id,
+                                      :code_string => 'inv-19')
+    expect {@entry.encoding = invalid_encoding}.to raise_error ArgumentError
+  end
+
+  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

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

@@ -0,0 +1,37 @@
+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::Text
+
+describe Evaluation 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')
+    @evaluation = Evaluation.new(:archetype_node_id => 'at0001',
+                                 :name => name,
+                                 :language => language,
+                                 :encoding => encoding,
+                                 :subject => subject,
+                                 :data => data)
+  end
+
+  it 'should be an instance of Evaluation' do
+    @evaluation.should be_an_instance_of Evaluation
+  end
+
+  it 'data should be properly assigned' do
+    @evaluation.data.archetype_node_id.should == 'at0002'
+  end
+
+  it 'should raise ArgumentError when nil assigned to data' do
+    lambda {
+      @evaluation.data = nil
+    }.should raise_error ArgumentError
+  end
+end

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

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::Support::Identification
+
+describe InstructionDetails do
+  before(:each) do
+    instruction_id = stub(LocatableRef, :path => '[instruction]/[test]')
+    wf_details = stub(ItemStructure, :archetype_node_id => 'at0004')
+    @instruction_details =
+      InstructionDetails.new(:instruction_id => instruction_id,
+                             :activity_id => 'at0003',
+                             :wf_details => wf_details)
+  end
+
+  it 'should be an instance of InstructionDetails' do
+    @instruction_details.should be_an_instance_of InstructionDetails
+  end
+
+  it 'instruction_id should be assigned properly' do
+    @instruction_details.instruction_id.path.should ==
+      '[instruction]/[test]'
+  end
+
+  it 'should raise ArgumentError with nil instruction_id' do
+    lambda {
+      @instruction_details.instruction_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'activity_id should be assigned properly' do
+    @instruction_details.activity_id.should == 'at0003'
+  end
+
+  it 'should raise ArgumentError with nil activity_id' do
+    lambda {
+      @instruction_details.activity_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty activity_id' do
+    lambda {
+      @instruction_details.activity_id = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'wf_details should be assigned properly' do
+    @instruction_details.wf_details.archetype_node_id.should == 
+      'at0004'
+  end
+end

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

@@ -0,0 +1,62 @@
+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::DataTypes::Quantity::DateTime
+include OpenEHR::RM::DataTypes::Encapsulated
+
+describe Instruction do
+#  it_should_behave_like 'entry'
+  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
+    narrative = DvText.new(:value => 'instruction test')
+    activities = stub(Array, :size => 5, :empty? => false)
+    expiry_time = DvDateTime.new(:value => '2009-11-18T20:58:34')
+    wf_definition = stub(DvParsable, :value => 'behavior driven')
+    @instruction= Instruction.new(:archetype_node_id => 'at0001',
+                                  :name => name,
+                                  :language => language,
+                                  :encoding => encoding,
+                                  :subject => subject,
+                                  :narrative => narrative,
+                                  :activities => activities,
+                                  :expiry_time => expiry_time,
+                                  :wf_definition => wf_definition)
+  end
+
+  it 'should be an instance of Instruction' do
+    @instruction.should be_an_instance_of Instruction
+  end
+
+  it 'narrative should be assigned properly' do
+    @instruction.narrative.value.should == 'instruction test'
+  end
+
+  it 'should raise ArgumentError when narrative is assined with nil' do
+    lambda {
+      @instruction.narrative = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'activities should be assigned properly' do
+    @instruction.activities.size.should be_equal 5
+  end
+
+  it 'should raise ArgumentError with empty activities' do
+    lambda {
+      @instruction.activities = [ ]
+    }.should raise_error ArgumentError
+  end
+
+  it 'expiry_time should be assigned properly' do
+    @instruction.expiry_time.value.should == '2009-11-18T20:58:34'
+  end
+
+  it 'wf_definition should be assigned properly' do
+    @instruction.wf_definition.value.should == 'behavior driven'
+  end
+end

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

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Text
+
+describe IsmTransition do
+  before(:each) do
+    current_state = stub(DvCodedText, :value => 'planned')
+    transition = stub(DvCodedText, :value => 'scheduled')
+    careflow_step = stub(DvCodedText, :value => 'completed')
+    @ism_transition = IsmTransition.new(:current_state => current_state,
+                                        :transition => transition,
+                                        :careflow_step => careflow_step)
+  end
+
+  it 'should be an instance of IsmTransition' do
+    @ism_transition.should be_an_instance_of IsmTransition
+  end
+
+  it 'current_status should be assigned properly' do
+    @ism_transition.current_state.value.should == 'planned'
+  end
+
+  it 'should raise ArgumentError with nil current state' do
+    lambda {
+      @ism_transition.current_state = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when current_state has invalid code'
+
+  it 'transition should be assined properly' do
+    @ism_transition.transition.value.should == 'scheduled'
+  end
+
+  it 'should raise ArgumentError with nil transition' do
+    lambda {
+      @ism_transition.transition = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArugmentError with invalid transition code'
+
+  it 'careflow_step should be assigned properly' do
+    @ism_transition.careflow_step.value.should == 'completed'
+  end
+end

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

@@ -0,0 +1,45 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+#require File.dirname(__FILE__) + '/shared_examples_spec'
+include OpenEHR::RM::DataStructures::History
+include OpenEHR::RM::Composition::Content::Entry
+include OpenEHR::RM::DataTypes::Text
+
+describe Observation do
+#  it_should_behave_like 'entry'
+  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
+    data = stub(History, :archetype_node_id => 'at0002')
+    state = stub(History, :archetype_node_id => 'at0003')
+    @observation = Observation.new(:archetype_node_id => 'at0001',
+                                   :name => name,
+                                   :language => language,
+                                   :encoding => encoding,
+                                   :subject => subject,
+                                   :data => data,
+                                   :state => state)
+  end
+
+  it 'should be an instance of Observation' do
+    @observation.should be_an_instance_of Observation
+  end
+
+  it 'data should be assigned properly' do
+    @observation.data.archetype_node_id.should == 'at0002'
+  end
+
+  it 'should raise ArgumentError when nil assigned to data' do
+    lambda {
+      @observation.data = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'state should be assigned properly' do
+    @observation.state.archetype_node_id.should == 'at0003'
+  end
+end

data/spec/lib/openehr/rm/composition/content/navigation/section_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::RM::Composition::Content::Navigation
+include OpenEHR::RM::DataTypes::Text
+
+describe Section do
+  before(:each) do
+    items = stub(Array, :empty? => false, :size => 10)
+    @section = Section.new(:archetype_node_id => 'at0001',
+                           :name => DvText.new(:value => 'section'),
+                           :items => items)
+  end
+
+  it 'should be an instance of Section' do
+    @section.should be_an_instance_of Section
+  end
+
+  it 'items should be assigned properly' do
+    @section.items.size.should be_equal 10
+  end
+
+  it 'empty items should raise ArgumentError' do
+    lambda {
+      @section.items = [ ]
+    }.should raise_error ArgumentError
+  end
+
+  it 'nil items should not raise ArgumentError' do
+    lambda {
+      @section.items = nil
+    }.should_not raise_error ArgumentError
+  end
+end