openehr 1.2.8 → 1.2.9

data/spec/lib/openehr/rm/data_types/text/term_mapping_spec.rb

@@ -1,59 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../spec_helper'
-include OpenEHR::RM::DataTypes::Text
-
-describe TermMapping do
-  before(:each) do
-    target_stub = stub(DvCodedText, :value => 'TEST')
-    purpose_stub = stub(DvCodedText, :value => 'automated')
-    @term_mapping = TermMapping.new(:target => target_stub,
-                                    :match => '=',
-                                    :purpose => purpose_stub)
-  end
-
-  it 'should means equivalent' do
-    @term_mapping.should be_equivalent
-  end
-
-  it 'should means narrower' do
-    @term_mapping.match = '<'
-    @term_mapping.should be_narrower
-  end
-
-  it 'should means broader' do
-    @term_mapping.match = '>'
-    @term_mapping.should be_broader
-  end
-
-  it 'should means unknown' do
-    @term_mapping.match = '?'
-    @term_mapping.should be_unknown
-  end
-
-  it 'should be valid match code >' do
-    TermMapping.is_valid_mach_code?('>').should be_true
-  end
-
-  it 'should be valid match code =' do
-    TermMapping.is_valid_mach_code?('=').should be_true
-  end
-
-  it 'should be valid match code <' do
-    TermMapping.is_valid_mach_code?('<').should be_true
-  end
-
-  it 'should be valid match code ?' do
-    TermMapping.is_valid_mach_code?('?').should be_true
-  end
-
-  it 'should be not valid code /' do
-    TermMapping.is_valid_mach_code?('/').should_not be_true
-  end
-
-  it 's purpose should == automated' do
-    @term_mapping.purpose.value.should == 'automated'
-  end
-
-  it 'should raise ArgumentError when match is not valid' do
-    lambda {@term_mapping.match = '/'}.should raise_error(ArgumentError)
-  end
-end

data/spec/lib/openehr/rm/data_types/uri/dv_ehr_uri_spec.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../spec_helper'
-include OpenEHR::RM::DataTypes::URI
-
-describe DvEhrUri do
-  before(:each) do
-    @dv_ehr_uri = DvEhrUri.new(:value => 'ehr://test/87284370-2D4B-4e3d-A3F3-F303D2F4F34B@2005-08-02T04:30:00')
-  end
-
-  it 'should be an instance of EhrUri' do
-    @dv_ehr_uri.should be_an_instance_of DvEhrUri
-  end
-
-  it 's value should be valid' do
-    @dv_ehr_uri.value.should == 
-      'ehr://test/87284370-2D4B-4e3d-A3F3-F303D2F4F34B@2005-08-02T04:30:00'
-  end
-
-  it 's scheme should be ehr' do
-    @dv_ehr_uri.scheme.should == 'ehr'
-  end
-end

data/spec/lib/openehr/rm/data_types/uri/dv_uri_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../spec_helper'
-include OpenEHR::RM::DataTypes::URI
-
-describe DvUri do
-  before(:each) do
-    @dv_uri = DvUri.new(:value => 
-                        "http://www.openehr.jp/changeset/test?cmd=93#file0")
-  end
-
-  it 's fragment_id should be file0' do
-    @dv_uri.fragment_id.should == 'file0'
-  end
-
-  it 's path should be /changeset/test' do
-    @dv_uri.path.should == '/changeset/test'
-  end
-
-  it 's query should be cmd=93' do
-    @dv_uri.query.should == 'cmd=93'
-  end
-
-  it 's scheme should be http' do
-    @dv_uri.scheme.should == 'http'
-  end
-
-  it 's value should be http://www.openehr.jp/changeset/test?cmd=93#file0' do
-    @dv_uri.value.should == 'http://www.openehr.jp/changeset/test?cmd=93#file0'
-  end
-
-  it 's value change' do
-    lambda {
-      @dv_uri.value="svn://www.openehr.jp/openehr-jp/"
-    }.should change(@dv_uri, :value).to('svn://www.openehr.jp/openehr-jp/')
-  end
-end
-

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

@@ -1,79 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../spec_helper'
-include OpenEHR::RM::Demographic
-include OpenEHR::RM::DataTypes::Text
-include OpenEHR::RM::Support::Identification
-
-describe Actor do
-  before(:each) do
-    name = DvText.new(:value => 'actor')
-    uid = HierObjectID.new(:value => '01')
-    identities = stub(Set, :empty? => false)
-    roles = stub(Set, :size => 2, :empty? => false)
-    languages = stub(Array, :size => 3, :empty? => false)
-    @actor = Actor.new(:archetype_node_id => 'at0000',
-                       :name => name,
-                       :uid => uid,
-                       :identities => identities,
-                       :roles => roles,
-                       :languages => languages)
-  end
-
-  it 'should be an instance of Actor' do
-    @actor.should be_an_instance_of Actor
-  end
-
-  it 'roles should be assigned properly' do
-    @actor.roles.size.should be_equal 2
-  end
-
-  it 'should raise ArgumentError with empty roles' do
-    lambda {
-      @actor.roles = Set.new
-    }.should raise_error ArgumentError
-  end
-
-  it 'should not raise ArgumentError with nil roles' do
-    lambda {
-      @actor.roles = nil
-    }.should_not raise_error ArgumentError
-  end
-
-  it 'languages should be assigned properly' do
-    @actor.languages.size.should be_equal 3
-  end
-
-  it 'should raise ArgumentError with empty languages' do
-    lambda {
-      @actor.languages = Set.new
-    }.should raise_error ArgumentError
-  end
-
-  it 'should not raise ArgumentError with nil languages' do
-    lambda {
-      @actor.languages = nil
-    }.should_not raise_error ArgumentError
-  end
-
-  describe 'has_legal_identity' do
-    before(:each) do
-      @dummy_purpose = DvText.new(:value => 'dummy')
-      @dummy_identity = stub(PartyIdentity, :purpose => @dummy_purpose)
-    end
-
-    it 'should not have legal identity' do
-      identity = stub(PartyIdentity, :purpose => @dummy_purpose)
-      identities = [identity, @dummy_identity].to_set
-      @actor.identities = identities
-      @actor.has_legal_identity?.should be_false
-    end
-
-    it 'should have legal identity' do
-      legal_purpose = DvText.new(:value => 'legal identity')
-      legal_identity = stub(PartyIdentity, :purpose => legal_purpose)
-      identities = [@dummy_identity, legal_identity].to_set
-      @actor.identities = identities
-      @actor.has_legal_identity?.should be_true
-    end
-  end
-end
-

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

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../spec_helper'
-include OpenEHR::RM::Demographic
-include OpenEHR::RM::DataTypes::Text
-include OpenEHR::RM::DataStructures::ItemStructure
-
-describe Address do
-  before(:each) do
-    name = DvText.new(:value => 'address')
-    details = stub(ItemStructure, :archetype_node_id => 'at0001')
-    @address = Address.new(:archetype_node_id => 'at0000',
-                           :name => name,
-                           :details => details)
-  end
-
-  it 'should be an instance of Address' do
-    @address.should be_an_instance_of Address
-  end
-
-  it 'type is inherit from name' do
-    @address.type.value.should == 'address'
-  end
-
-  it 'details should be assigned properly' do
-    @address.details.archetype_node_id.should == 'at0001'
-  end
-
-  it 'should raise ArgumentError with nil details' do
-    lambda {
-      @address.details = nil
-    }.should raise_error ArgumentError
-  end
-end
-

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

@@ -1,37 +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
-include OpenEHR::RM::DataStructures::ItemStructure
-
-describe Capability do
-  before(:each) do
-    name = DvText.new(:value => 'party relation')
-    credentials = stub(ItemStructure, :archetype_node_id => 'at0001')
-    lower = DvDate.new(:value => '2009-11-21')
-    time_validity = stub(DvInterval, :lower => lower)
-    @capability = Capability.new(:archetype_node_id => 'at0000',
-                                 :name => name,
-                                 :credentials => credentials,
-                                 :time_validity => time_validity)
-  end
-
-  it 'should be an instance of Capability' do
-    @capability.should be_an_instance_of Capability
-  end
-
-  it 'credential should be assigned properly' do
-    @capability.credentials.archetype_node_id.should == 'at0001'
-  end
-
-  it 'should raise ArgumentError when nil assigned to credentials' do
-    lambda {
-      @capability.credentials = nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'time_validity should be assigned properly' do
-    @capability.time_validity.lower.value.should == '2009-11-21'
-  end
-end

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

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../spec_helper'
-include OpenEHR::RM::Demographic
-include OpenEHR::RM::DataTypes::Quantity::DateTime
-include OpenEHR::RM::DataTypes::Text
-
-describe Contact do
-  before(:each) do
-    name = DvText.new(:value => 'contact')
-    addresses = stub(Array, :size => 2, :empty? => false)
-    upper = DvDate.new(:value => '2009-11-20')
-    time_validity = stub(DvInterval, :upper => upper)
-    @contact = Contact.new(:archetype_node_id => 'at0000',
-                           :name => name,
-                           :addresses => addresses,
-                           :time_validity => time_validity)
-  end
-
-  it 'should be an instance of Contact' do
-    @contact.should be_an_instance_of Contact
-  end
-
-  it 'addresses should be assigned properly' do
-    @contact.addresses.size.should == 2
-  end
-
-  it 'should raise ArgumentError with nil address' do
-    lambda {
-      @contact.addresses = nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'should raise ArgumentError with empty addresses' do
-    lambda {
-      @contact.addresses = [ ]
-    }.should raise_error ArgumentError
-  end
-
-  it 'time_validity should be assigned properly' do
-    @contact.time_validity.upper.value.should == '2009-11-20'
-  end
-
-  it 'purpose should be inherit as name' do
-    @contact.purpose.value.should == 'contact'
-  end
-end

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

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../spec_helper'
-include OpenEHR::RM::Demographic
-include OpenEHR::RM::DataTypes::Text
-include OpenEHR::RM::DataStructures::ItemStructure
-
-describe PartyIdentity do
-  before(:each) do
-    name = DvText.new(:value => 'test')
-    details = stub(ItemStructure, :archetype_node_id => 'at0002')
-    @party_identity = PartyIdentity.new(:archetype_node_id => 'at0001',
-                                        :name => name,
-                                        :details => details)
-  end
-
-  it 'should be an instance of PartyIdentity' do
-    @party_identity.should be_an_instance_of PartyIdentity
-  end
-
-  it 'details should be assigned properly' do
-    @party_identity.details.archetype_node_id.should == 'at0002'
-  end
-
-  it 'should raise ArgumentError with nil details' do
-    lambda {
-      @party_identity.details = nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'purpose should return as same as name' do
-    @party_identity.purpose.value.should == 'test'
-  end
-end

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

@@ -1,84 +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
-include OpenEHR::RM::DataStructures::ItemStructure
-
-describe PartyRelationship do
-  before(:each) do
-    name = DvText.new(:value => 'party relation')
-    uid = HierObjectID.new(:value => '01')
-    details = stub(ItemStructure, :archetype_node_id => 'at0002')
-    upper = DvDate.new(:value => '2009-11-21')
-    time_validity = stub(DvInterval, :upper => upper)
-    source_id = ObjectID.new(:value => '01')
-    source = stub(PartyRef, :id => source_id, :type => 'source')
-    target_id = ObjectID.new(:value => '02')
-    target = stub(PartyRef, :id => target_id)
-    @party_relationship =
-      PartyRelationship.new(:archetype_node_id => 'at0000',
-                            :name => name,
-                            :uid => uid,
-                            :details => details,
-                            :time_validity => time_validity,
-                            :source => source,
-                            :target => target)
-  end
-
-  it 'should be an instance of PartyRelationship' do
-    @party_relationship.should be_an_instance_of PartyRelationship
-  end
-
-  it 'uid should be assigned properly' do
-    @party_relationship.uid.value.should == '01'
-  end
-
-  it 'should raise ArgumentError when nil assigned to uid' do
-    lambda {
-      @party_relationship.uid = nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'details should be assigned properly' do
-    @party_relationship.details.archetype_node_id.should == 'at0002'
-  end
-
-  it 'time_validity should be assigned properly' do
-    @party_relationship.time_validity.upper.value.should == '2009-11-21'
-  end
-
-  it 'source should be_assigned properly' do
-    @party_relationship.source.type.should == 'source'
-  end
-
-  it 'should raise ArgumentError when source is assinged nil' do
-    lambda {
-      @party_relationship.source = nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'should raise ArgumentError when source is not matched with source' do
-    invalid_id = ObjectID.new(:value => '10')
-    invalid_source = stub(PartyRef, :id => invalid_id)
-    lambda {
-      @party_relationship.source = invalid_source
-    }.should raise_error ArgumentError
-  end
-
-  it 'target should be assined properly' do
-    @party_relationship.target.id.value.should == '02'
-  end
-
-  it 'should raise ArgumentError with target is assigned by nil' do
-    lambda {
-      @party_relationship.target =nil
-    }.should raise_error ArgumentError
-  end
-
-  it 'type should be inherited of name' do
-    @party_relationship.type.value.should == 'party relation'
-  end
-end
-  
-                            

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

@@ -1,131 +0,0 @@
-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
-    expect {@party.identities = Set.new}.to raise_error
-  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
-