openehr 1.2.8 → 1.2.9

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

@@ -1,58 +0,0 @@
-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/openehr/rm/ehr/ehr_access_spec.rb

@@ -1,33 +0,0 @@
-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/openehr/rm/ehr/ehr_spec.rb

@@ -1,139 +0,0 @@
-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/openehr/rm/ehr/ehr_status_spec.rb

@@ -1,52 +0,0 @@
-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/openehr/rm/ehr/versioned_composition_spec.rb

@@ -1,33 +0,0 @@
-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/openehr/rm/factory_spec.rb

@@ -1,189 +0,0 @@
-require  File.dirname(__FILE__) + '/../../../spec_helper'
-
-module OpenEHR
-  module RM
-    describe Factory do
-      describe DvBooleanFactory do
-        subject { Factory.create('DvBoolean', value: true) }
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Basic::DvBoolean }
-      end
-
-      describe DvStateFactory do
-        subject { Factory.create('DV_STATE', value: double(), terminal: true) }
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Basic::DvState }
-      end
-
-      describe DvIdentifierFactory do
-        subject { Factory.create('DV_IDENTIFIER',
-                                 issuer: 'Ehime univ', assigner: 'Hospital',
-                                 id: '012345', type: 'local id') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Basic::DvIdentifier }
-      end
-
-      describe DvTextFactory do
-        subject { Factory.create("DvText", value: 'text') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::DvText }
-      end
-
-      context "DV_TEXT mapped to camelized RM type" do
-        subject { Factory.create('DV_TEXT', value:'text') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::DvText }
-      end
-
-      describe TermMappingFactory do
-        let(:target) { double() }
-        subject { Factory.create('TERM_MAPPING', target: target, match: '=') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::TermMapping }
-      end
-
-      describe CodePhraseFactory do
-        let(:terminology_id) { double() }
-        subject { Factory.create('CODE_PHRASE',
-                                 terminology_id: terminology_id,
-                                 code_string: 'C890') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::CodePhrase }
-      end
-
-      describe DvCodedTextFactory do
-        subject { Factory.create('DV_CODED_TEXT', value: 'C089', defining_code: double()) }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::DvCodedText }
-      end
-
-      describe DvParagraphFactory do
-        let(:items) { ['short sentence', 'long sentence']}
-        subject { Factory.create('DV_PARAGRAPH', items: items) }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Text::DvParagraph }
-      end
-
-      describe DvOrderedFactory do
-        subject { Factory.create('DV_ORDERED') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DvOrdered }
-      end
-
-      describe DvIntervalFactory do
-        subject { Factory.create('DV_INTERVAL', upper: 100, lower: 1) }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DvInterval }
-      end
-
-      describe ReferenceRangeFactory do
-        subject { Factory.create('REFERENCE_RANGE', meaning: 'spec', range: double) }
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::ReferenceRange }
-      end
-
-      describe DvOrdinalFactory do
-        subject { Factory.create('DV_ORDINAL', value: 1, symbol: double()) }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DvOrdinal }
-      end
-
-      describe DvQuantifiedFactory do
-        subject { Factory.create('DV_QUANTIFIED', magnitude: 1) }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DvQuantified }
-      end
-
-      describe DvAmountFactory do
-        subject { Factory.create('DV_AMOUNT', magnitude: 0) }
-
-        it { should be_an_instance_of DataTypes::Quantity::DvAmount }
-      end
-
-      describe DvQuantityFactory do
-        subject { Factory.create("DvQuantity", magnitude: 10, units: 'mg') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DvQuantity }
-      end
-
-      describe DvCountFactory do
-        subject { Factory.create("DV_COUNT", magnitude: 3) }
-
-        it { should be_an_instance_of DataTypes::Quantity::DvCount }
-      end
-
-      describe DvProportionFactory do
-        subject { Factory.create('DV_PROPORTION', numerator: 2, denominator: 1,
-                      type: DataTypes::Quantity::ProportionKind::PK_UNITARY) }
-
-        it { should be_an_instance_of DataTypes::Quantity::DvProportion }
-      end
-
-      describe DvAbsoluteQuantityFactory do
-        subject { Factory.create('DV_ABSOLUTE_QUANTITY', magnitude: 6) }
-
-        it { should be_an_instance_of DataTypes::Quantity::DvAbsoluteQuantity }
-      end
-
-      describe DvTemporalFactory do
-        subject { Factory.create('DV_TEMPORAL', value: '2013-02-20T02:09:30') }
-
-        it { should be_an_instance_of DataTypes::Quantity::DateTime::DvTemporal }
-      end
-
-      describe DvDateFactory do
-        subject { Factory.create("DV_DATE", value: '2013-02-19') }
-
-        it { should be_an_instance_of OpenEHR::RM::DataTypes::Quantity::DateTime::DvDate }
-      end
-
-      describe DvTimeFactory do
-        subject { Factory.create('DV_TIME', value: '02:13:39') }
-
-        it { should be_an_instance_of DataTypes::Quantity::DateTime::DvTime }
-      end
-
-      describe DvDateTimeFactory do
-        subject { Factory.create('DV_DATE_TIME', value: '2013-02-21T01:02:23') }
-
-        it { should be_an_instance_of DataTypes::Quantity::DateTime::DvDateTime }
-      end
-
-      describe DvDurationFactory do
-        subject { Factory.create('DV_DURATION', value: 'P1Y2M') }
-
-        it { should be_an_instance_of DataTypes::Quantity::DateTime::DvDuration }
-      end
-
-      describe DvEncapsulatedFactory do
-        subject { Factory.create('DV_ENCAPSULATED', value: 'sample') }
-
-        it { should be_an_instance_of DataTypes::Encapsulated::DvEncapsulated }
-      end
-
-      describe DvMultimediaFactory do
-        subject { media_type = stub('media_type')
-          media_type.stub(:code_string).and_return('SVG')
-          Factory.create('DV_MULTIMEDIA', value: '<SVG> test </SVG>',
-                                 media_type: media_type) }
-
-        it { should be_an_instance_of DataTypes::Encapsulated::DvMultimedia }
-      end
-
-      describe DvParsableFactory do
-        subject { Factory.create('DvParsable', value: 'test', formalism: 'plain/text') }
-
-        it { should be_an_instance_of DataTypes::Encapsulated::DvParsable }
-      end
-
-      describe DvUriFactory do
-        subject { Factory.create('DV_URI', value: 'http://openehr.jp') }
-
-        it { should be_an_instance_of DataTypes::URI::DvUri }
-      end
-
-      describe DvEhrUriFactory do
-        subject { Factory.create('DV_EHR_URI', value: 'ehr://test/87284370-2D4B-4e3d-A3F3-F303D2F4F34B@2005-08-02T04:30:00') }
-
-        it { should be_an_instance_of DataTypes::URI::DvEhrUri }
-      end
-    end
-  end
-end