openehr 1.2.8 → 1.2.9

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

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

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

@@ -1,95 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../../spec_helper'
-
-describe OpenEHR::RM::Composition::Content::Entry::Entry do
-
-  let(:name) {OpenEHR::RM::DataTypes::Text::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(OpenEHR::RM::Support::Identification::PartyRef, :type => 'entry')
-    subject = OpenEHR::RM::Common::Generic::PartyProxy.new(:external_ref => external_ref)
-    provider_external_ref = stub(OpenEHR::RM::Support::Identification::PartyRef, :type => 'provider')
-    provider = OpenEHR::RM::Common::Generic::PartyProxy.new(:external_ref => provider_external_ref)
-    other_participations = stub(Array, :size => 3, :empty? => false)
-    workflow_id = stub(OpenEHR::RM::Support::Identification::ObjectRef, :type => 'workflow')
-    @entry = OpenEHR::RM::Composition::Content::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 OpenEHR::RM::Composition::Content::Entry::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 = OpenEHR::RM::Support::Identification::TerminologyID.new(:value => 'ISO639-1')
-    invalid_language = OpenEHR::RM::DataTypes::Text::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 = OpenEHR::RM::Support::Identification::TerminologyID.new(:value => 'ISO639-1')
-    invalid_encoding = OpenEHR::RM::DataTypes::Text::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 = OpenEHR::RM::Common::Generic::PartySelf.new
-    @entry.subject_is_self?.should be_true
-  end
-end

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

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

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

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

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

@@ -1,45 +0,0 @@
-$:.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

@@ -1,34 +0,0 @@
-#require File.dirname(__FILE__) + '/../../../../../../spec_helper'
-require 'spec_helper'
-#include 
-include OpenEHR::RM::DataTypes::Text
-
-describe OpenEHR::RM::Composition::Content::Navigation::Section do
-  before(:each) do
-    items = stub(Array, :empty? => false, :size => 10)
-    @section = OpenEHR::RM::Composition::Content::Navigation::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