open_ehr 0.6.1

data/spec/lib/open_ehr/rm/demographic/party_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::Demographic
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataStructures::ItemStructure
+
+describe Party do
+  before(:each) do
+    name = DvText.new(:value => 'PARTY')
+    uid = HierObjectID.new(:value => '01')
+    identities = stub(Set, :empty? => false, :size => 2)
+    contacts = stub(Set, :size => 3, :empty? => false)
+    cur_id = stub(ObjectID, :value => '01')
+    cur_source = stub(PartyRef, :id => cur_id)
+    id1 = stub(ObjectID, :value => '03')
+    targ1 = stub(PartyRef, :id => id1)
+    rel1 = stub(PartyRelationship, :source => cur_source,
+                :target => targ1)
+    id2 = stub(ObjectID, :value => '04')
+    targ2 = stub(PartyRef, :id => id2)
+    rel2 = stub(PartyRelationship, :source => cur_source,
+                :target => targ2)
+    id3 = stub(ObjectID, :value => '05')
+    targ3 = stub(PartyRef, :id => id3) 
+    rel3 = stub(PartyRelationship, :source => cur_source,
+                :target => targ3)
+    id4 = stub(ObjectID, :value => '06')
+    targ4 = stub(PartyRef, :id => id4)
+    rel4 = stub(PartyRelationship, :source => cur_source,
+                :target => targ4)
+    relationships = [rel1, rel2, rel3, rel4].to_set
+    reverse_relationships = stub(Set, :empty? => false, :size => 5)
+    details = stub(ItemStructure, :archetype_node_id => 'at0005')
+    @party = Party.new(:archetype_node_id => 'at0001',
+                       :name => name,
+                       :uid => uid,
+                       :identities => identities,
+                       :contacts => contacts,
+                       :relationships => relationships,
+                       :reverse_relationships => reverse_relationships,
+                       :details => details)
+  end
+
+  it 'should be an instance of Party' do
+    @party.should be_an_instance_of Party
+  end
+
+  it 'uid should be assigned properly' do
+    @party.uid.value.should == '01'
+  end
+
+  it 'should raise ArgumentError with nil uid' do
+    lambda {
+      @party.uid = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'identities should be assigned properly' do
+    @party.identities.size.should be_equal 2
+  end
+
+  it 'should raise ArgumentError when nil identities are assigned' do
+    lambda {
+      @party.identities = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when identities are empty' do
+    lambda {
+      @party.identities = Set.new
+    }
+  end
+
+  it 'type should be alias of name' do
+    @party.type.value.should == 'PARTY'
+  end
+
+  it 'contacts should be assigned properly' do
+    @party.contacts.size.should be_equal 3
+  end
+
+  it 'should raise ArgumentError with empty contacts' do
+    lambda {
+      @party.contacts = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'relationships should be assigned properly' do
+    target_ids = Set.new
+    @party.relationships.each do |rel|
+      target_ids << rel.target.id.value
+    end
+    target_ids.should == %w{03 04 05 06}.to_set
+  end
+
+  it 'should not raise ArgumentError with nil relationships' do
+    lambda {
+      @party.relationships = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty relationships' do
+    lambda {
+      @party.relationships = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'invaild relationship raise ArgumentError' do
+    invalid_id = stub(ObjectID, :value => '10')
+    invalid_source = stub(PartyRef, :id => invalid_id)
+    invalid_rel = stub(PartyRelationship, :source => invalid_source)
+    lambda {
+      @party.relationships = [invalid_rel].to_set
+    }.should raise_error ArgumentError
+  end
+
+  it 'reverse relationship should be assigned properly' do
+    @party.reverse_relationships.size.should be_equal 5
+  end
+
+  it 'reverse_relationships should not be empty' do
+    lambda {
+      @party.reverse_relationships = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'should validate reverse_relationships'
+
+  it 'details should be assigned properly' do
+    @party.details.archetype_node_id.should == 'at0005'
+  end
+end
+

data/spec/lib/open_ehr/rm/demographic/role_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::Demographic
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+include OpenEHR::RM::Support::Identification
+
+describe Role do
+  before(:each) do
+    name = DvText.new(:value => 'role')
+    uid = HierObjectID.new(:value => '01')
+    identities = stub(Set, :empty? => false)
+    capabilities = stub(Array, :size => 2, :empty? => false)
+    lower = DvDate.new(:value => '2009-11-21')
+    time_validity = stub(DvInterval, :lower => lower)
+    performer = stub(PartyRef, :type => 'ROLE')
+    @role = Role.new(:archetype_node_id => 'at0000',
+                     :name => name,
+                     :uid => uid,
+                     :identities => identities,
+                     :performer => performer,
+                     :capabilities => capabilities,
+                     :time_validity => time_validity)
+  end
+
+  it 'should be an instance of Role' do
+    @role.should be_an_instance_of Role
+  end
+
+  it 'performer should assigned properly' do
+    @role.performer.type.should == 'ROLE'
+  end
+
+  it 'should raise ArgumentError with nil performer' do
+    lambda {
+      @role.performer = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'capabilities should be assigned properly' do
+    @role.capabilities.size.should be_equal 2
+  end
+
+  it 'should raise ArgumentError with empty capabilities' do
+    lambda {
+      @role.capabilities = [ ]
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil capabilities' do
+    lambda {
+      @role.capabilities = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'time_validity should be properly assigned' do
+    @role.time_validity.lower.value.should == '2009-11-21'
+  end
+end

data/spec/lib/open_ehr/rm/ehr/ehr_access_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::EHR
+include OpenEHR::RM::Security
+include OpenEHR::RM::DataTypes::Text
+
+describe EHRAccess do
+  before(:each) do
+    name = DvText.new(:value => 'EHRAccess')
+    settings = stub(AccessControlSettings)
+    @ehr_access = EHRAccess.new(:archetype_node_id => 'at0001',
+                                :name => name,
+                                :settings => settings,
+                                :scheme => 'SSL')
+  end
+
+  it 'should be an instance of EHRAccess' do
+    @ehr_access.should be_an_instance_of EHRAccess
+  end
+
+  it 'settings should be assigned, but Security package is not determined' do
+    @ehr_access.settings.should_not be_nil
+  end
+
+  it 'schema should be assigned properly' do
+    @ehr_access.scheme.should == 'SSL'
+  end
+
+  it 'should raise ArgumentError with nil schema' do
+    lambda {
+      @ehr_access.scheme = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/ehr/ehr_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::EHR
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe EHR do
+  before(:each) do
+    system_id = HierObjectID.new(:value => 'ABC::DEF')
+    ehr_id = HierObjectID.new(:value => 'GHI::JKL')
+    time_created = DvDateTime.new(:value => '2009-11-14T19:01:11')
+    ehr_access = stub(ObjectRef, :type => 'VERSIONED_EHR_ACCESS')
+    ehr_status = stub(ObjectRef, :type => 'VERSIONED_EHR_STATUS')
+    contribution1 = stub(ObjectRef, :type => 'CONTRIBUTION')
+    contribution2 = stub(ObjectRef, :type => 'CONTRIBUTION')
+    contributions = [contribution1, contribution2]
+    directory = stub(ObjectRef, :type => 'VERSIONED_FOLDER')
+    composition1 = stub(ObjectRef, :type => 'VERSIONED_COMPOSITION')
+    composition2 = stub(ObjectRef, :type => 'VERSIONED_COMPOSITION')
+    composition3 = stub(ObjectRef, :type => 'VERSIONED_COMPOSITION')
+    compositions = [composition1, composition2, composition3]
+    @ehr = EHR.new(:system_id => system_id,
+                   :ehr_id => ehr_id,
+                   :time_created => time_created,
+                   :contributions => contributions,
+                   :ehr_access => ehr_access,
+                   :ehr_status => ehr_status,
+                   :directory => directory,
+                   :compositions => compositions)
+  end
+
+  it 'should be an instance of EHR' do
+    @ehr.should be_an_instance_of EHR
+  end
+
+  it 'system_id should be assigned properly' do
+    @ehr.system_id.value.should == 'ABC::DEF'
+  end
+
+  it 'should raise ArgumentError with nil system_id' do
+    lambda {
+      @ehr.system_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'ehr_id should be assigned properly' do
+    @ehr.ehr_id.value.should == 'GHI::JKL'
+  end
+
+  it 'should raise ArgumentError with nil ehr_id' do
+    lambda {
+      @ehr.ehr_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'time_created should be assigned properly' do
+    @ehr.time_created.value.should == '2009-11-14T19:01:11'
+  end
+
+  it 'should raise ArgumentError with nil time_created' do
+    lambda {
+      @ehr.time_created = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'contributions should properly assigned' do
+    @ehr.contributions.size.should be_equal 2
+  end
+
+  it 'type contributions should be CONTRIBUTION' do
+    contributions = [stub(ObjectRef, :type => 'PARTY')]
+    lambda {
+      @ehr.contributions = contributions
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil contributions' do
+    lambda {
+      @ehr.contributions = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'ehr_access should be assigned properly' do
+    @ehr.ehr_access.type.should == 'VERSIONED_EHR_ACCESS'
+  end
+
+  it 'should raise ArgumentError with nil ehr_access' do
+    lambda {
+      @ehr.ehr_access = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArguemntError with invalid ehr_access type' do
+    lambda {
+      @ehr.ehr_access = stub(ObjectRef, :type => 'VERSIONED_EHR_STATUS')
+    }.should raise_error ArgumentError
+  end
+    
+  it 'ehr_status should be assigned properly' do
+    @ehr.ehr_status.type.should == 'VERSIONED_EHR_STATUS'
+  end
+
+  it 'should raise ArgumentError with nil ehr_status' do
+    lambda {
+      @ehr.ehr_status = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invalid ehr_statsu type' do
+    lambda {
+      @ehr.ehr_status = stub(ObjectRef, :type => 'VERSIONED_EHR_ACCESS')
+    }.should raise_error ArgumentError
+  end
+
+  it 'should assigned compositions properly' do
+    @ehr.compositions.size.should be_equal 3
+  end
+
+  it 'should raise ArgumentError with nil compositions' do
+    lambda {
+      @ehr.compositions = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with invalid type composition' do
+    lambda {
+      @ehr.compositions = [stub(ObjectRef, :type => 'INVALID_COMPOSITION')]
+    }.should raise_error ArgumentError
+  end
+
+  it 'should assigned directory properly' do
+    @ehr.directory.type.should == 'VERSIONED_FOLDER'
+  end
+
+  it 'should raise ArgumentError with invalid type' do
+    lambda {
+      @ehr.directory = stub(ObjectRef, :type => 'INVALID_FOLDER')
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/ehr/ehr_status_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::EHR
+include OpenEHR::RM::Common::Generic
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Support::Identification
+include OpenEHR::RM::DataStructures::ItemStructure
+
+describe EHRStatus do
+  before(:each) do
+    external_ref = stub(PartyRef, :namespace => 'ehr status')
+    subject = PartySelf.new(:external_ref => external_ref)
+    other_details = stub(ItemStructure, :archetype_node_id => 'at0005')
+    @ehr_status = EHRStatus.new(:archetype_node_id => 'at0001',
+                                :name => DvText.new(:value => 'ehrstatus'),
+                                :subject => subject,
+                                :is_queryable => false,
+                                :is_modifiable => true,
+                                :other_details => other_details)
+  end
+
+  it 'should be an instance of EHRStatus' do
+    @ehr_status.should be_an_instance_of EHRStatus
+  end
+
+  it 'subject should be assigned properly' do
+    @ehr_status.subject.external_ref.namespace.should == 'ehr status'
+  end
+
+  it 'should raise ArgumentError with nil subject' do
+    lambda {
+      @ehr_status.subject = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'is_queryable should be properly assigned' do
+    @ehr_status.is_queryable?.should be_false
+  end
+
+  it 'is_modifiable should be assigned properly' do
+    @ehr_status.is_modifiable?.should be_true
+  end
+
+  it 'other_details should be assigned properly' do
+    @ehr_status.other_details.archetype_node_id.should == 'at0005'
+  end
+
+  it 'should raise ArgumentError when parant is not nil' do
+    lambda {
+      @ehr_status.parent = 'parent'
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/rm/ehr/versioned_composition_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::EHR
+include OpenEHR::RM::Composition
+include OpenEHR::RM::Common::ChangeControl
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::DataTypes::Quantity::DateTime
+
+describe VersionedComposition do
+  before(:each) do
+    composition1 = stub(Composition, :archetype_node_id => 'at0002',
+                        :is_persistent? => true)
+    version1 = stub(Version, :data => composition1)
+    composition2 = stub(Composition, :archetype_node_id => 'at0002',
+                        :is_persistent? => false)
+    version2 = stub(Version, :data => composition2)
+    uid = HierObjectID.new(:value => 'opeehr.jp::350')
+    owner_id = stub(ObjectRef, :type => 'EHR')
+    time_created = DvDateTime.new(:value => '2009-11-16T15:14:33')
+    @versioned_composition = 
+      VersionedComposition.new(:uid => uid,
+                               :owner_id => owner_id,
+                               :time_created => time_created,
+                               :all_versions => [version1, version2])
+  end
+
+  it 'should be an instance of VersionedComposition' do
+    @versioned_composition.should be_an_instance_of VersionedComposition
+  end
+
+  it 'is_persistent? should be evaluated by first version' do
+    @versioned_composition.is_persistent?.should be_true
+  end
+end

data/spec/lib/open_ehr/rm/integration/generic_entry_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+include OpenEHR::RM::Integration
+include OpenEHR::RM::DataStructures::ItemStructure
+include OpenEHR::RM::DataTypes::Text
+
+describe GenericEntry do
+  before(:each) do
+    data = stub(ItemTree, :archetype_node_id => 'at0003')
+    name = DvText.new(:value => 'generic entry')
+    @generic_entry = GenericEntry.new(:archetype_node_id => 'at0001',
+                                      :name => name,
+                                      :data => data)
+  end
+
+  it 'should be an instance of GenericEntry' do
+    @generic_entry.should be_an_instance_of GenericEntry
+  end
+
+  it 'data should be assigned properly' do
+    @generic_entry.data.archetype_node_id.should == 'at0003'
+  end
+
+  it 'should raise ArgumentError when data are nil' do
+    lambda {
+      @generic_entry.data = nil
+    }.should raise_error ArgumentError
+  end
+end
+                                      
+
+  

data/spec/lib/open_ehr/rm/support/identification/access_group_ref_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Support::Identification
+
+describe AccessGroupRef do
+  before(:each) do
+    object_id = ObjectID.new(:value => 'deadbeefbabe')
+    @access_group_ref = AccessGroupRef.new(:id => object_id,
+                                           :type => 'ACCESS_GROUP',
+                                           :namespace => 'unknown')
+  end
+
+  it 'should be an instance of AccessGroupRef' do
+    @access_group_ref.should be_an_instance_of AccessGroupRef
+  end
+
+  it 'type should be equal ACCESS_GROUP' do
+    @access_group_ref.type.should == 'ACCESS_GROUP'
+  end
+end

data/spec/lib/open_ehr/rm/support/identification/archetype_id_spec.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Support::Identification
+
+describe ArchetypeID do
+  before(:each) do
+    @archetype_id = ArchetypeID.new(:value => 'openEHR-EHR-SECTION.physical_examination-prenatal.v2')
+  end
+
+  it 'should be an instance of ArchetypeID' do
+    @archetype_id.should be_an_instance_of ArchetypeID
+  end
+
+  it 's value should be equal
+       openEHR-EHR-SECTION.physical_examination-prenatal.v2' do
+    @archetype_id.value.should ==
+      'openEHR-EHR-SECTION.physical_examination-prenatal.v2'
+  end
+  it 's qualified_rm_entity should be openEHR-EHR-SECTION' do
+    @archetype_id.qualified_rm_entity.should == 'openEHR-EHR-SECTION'
+  end
+
+  it 's rm_originator should be openEHR' do
+    @archetype_id.rm_originator.should == 'openEHR'
+  end
+
+  it 's rm_name should be EHR' do
+    @archetype_id.rm_name.should == 'EHR'
+  end
+
+  it 'rm_entity should be SECTION' do
+    @archetype_id.rm_entity.should == 'SECTION'
+  end
+
+  it 's domain_concept should be physical_examination-prenatal' do
+    @archetype_id.domain_concept.should == 'physical_examination-prenatal'
+  end
+
+  it 's concept name should be physical_examination' do
+    @archetype_id.concept_name.should == 'physical_examination'
+  end
+
+  it 's specialisation should be prenatal' do
+    @archetype_id.specialisation.should == 'prenatal'
+  end
+
+  it 's version_id should == v2' do
+    @archetype_id.version_id.should == 'v2'
+  end
+
+  it 'should raise ArgumentError with wrong id format' do
+    lambda {
+      ArchetypeID.new(:value =>'wrong-format')
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil concept name' do
+    lambda {
+      @archetype_id.concept_name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with wrong domain concept format' do
+    lambda {
+      @archetype_id.domain_concept = '0123'
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty rm_entity' do
+    lambda {
+      @archetype_id.rm_entity = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil rm_entity' do
+    lambda {
+      @archetype_id.rm_entity = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty rm_originator' do
+    lambda {
+      @archetype_id.rm_originator = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with nil rm_originator' do
+    lambda {
+      @archetype_id.rm_originator = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty specialisation' do
+    lambda {
+      @archetype_id.specialisation = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError with nil specialisation' do
+    lambda {
+      @archetype_id.specialisation = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  describe 'another constructor' do
+    before(:each) do
+      @archetype_id = ArchetypeID.new(:rm_originator => 'openEHR',
+                                      :rm_name => 'EHR',
+                                      :rm_entity => 'EVALUATION',
+                                      :concept_name => 'clinical_synopsis',
+                                      :version_id => 'v1')
+    end
+
+    it 'should be an instance of ArchetypeID' do
+      @archetype_id.should be_an_instance_of ArchetypeID
+    end
+
+    it 'domain_concept should be clinical_synopsis' do
+      @archetype_id.domain_concept.should == 'clinical_synopsis'
+    end
+  end
+
+  describe 'domain concept' do
+    before(:each) do
+      @archetype_id.domain_concept = 'progress_note-naturopathy'
+    end
+
+    it 'concept_name should be progress note' do
+      @archetype_id.concept_name.should == 'progress_note'
+    end
+
+    it 'specialisation should be naturopathy' do
+      @archetype_id.specialisation === 'naturopathy'
+    end
+
+    it 'should raise ArgumentError empty domain concept' do
+      lambda {
+        @archetype_id.domain_concept = ''
+      }.should raise_error ArgumentError
+    end
+
+    it 'should raise ArgumentError nil domain concept' do
+      lambda {
+        @archetype_id.domain_concept = nil
+      }.should raise_error ArgumentError
+    end
+
+    it 's specialisation may be empty' do
+      @archetype_id.domain_concept = 'clinical_synopsis'
+      @archetype_id.concept_name.should == 'clinical_synopsis'
+    end
+  end
+end

data/spec/lib/open_ehr/rm/support/identification/generic_id_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::RM::Support::Identification
+
+describe GenericID do
+  before(:each) do
+    @generic_id = GenericID.new(:value => '791-0245',
+                                :scheme => 'ZIP')
+  end
+
+  it 'should be an instance of GenericID' do
+    @generic_id.should be_an_instance_of GenericID
+  end
+
+  it 's value should be 791-0245' do
+    @generic_id.value.should == '791-0245'
+  end
+
+  it 's scheme should be ZIP' do
+    @generic_id.scheme.should == 'ZIP'
+  end
+
+  it 'should raise ArgumentError with nil scheme' do
+    lambda {
+      @generic_id.scheme = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError with empty scheme' do
+    lambda {
+      @generic_id.scheme = ''
+    }.should raise_error ArgumentError
+  end
+end