open_ehr 0.6.1

data/spec/lib/open_ehr/am/archetype/assertion/expr_unary_operator_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprUnaryOperator do
+  before(:each) do
+    operator = OperatorKind.new(:value => 2001)
+    operand = stub(ExprItem, :type => 'Real')
+    @expr_unary_operator =
+      ExprUnaryOperator.new(:type => 'Integer',
+                            :item => 'ANY',
+                            :reference_type => 'operator',
+                            :operator => operator,
+                            :precedence_overridden => true,
+                            :operand => operand)
+  end
+
+  it 'operand shoud be assigned properly' do
+    @expr_unary_operator.operand.type.should == 'Real'
+  end
+
+  it 'should raise ArgumentError when operand is nil' do
+    lambda {
+      @expr_unary_operator.operand = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/assertion/operator_kind_spec.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe OperatorKind do
+  it 'op_eq should be equal 2001' do
+    OperatorKind::OP_EQ.should be_equal 2001
+  end
+
+  it 'op_ne should be equal 2002' do
+    OperatorKind::OP_NE.should be_equal 2002
+  end
+
+  it 'op_le should be equal 2004' do
+    OperatorKind::OP_LE.should be_equal 2003
+  end
+
+  it 'op_lt should be equal 2004' do
+    OperatorKind::OP_LT.should be_equal 2004
+  end
+
+  it 'op_ge should be equal 2005' do
+    OperatorKind::OP_GE.should be_equal 2005
+  end
+
+  it 'op_gt should be equal 2006' do
+    OperatorKind::OP_GT.should be_equal 2006
+  end
+
+  it 'op_not should be equal 2010' do
+    OperatorKind::OP_NOT.should be_equal 2010
+  end
+
+  it 'op_and should be equal 2011' do
+    OperatorKind::OP_AND.should be_equal 2011
+  end
+
+  it 'op_or should be equal 2012' do
+    OperatorKind::OP_OR.should be_equal 2012
+  end
+
+  it 'op_xor should be equal 2013' do
+    OperatorKind::OP_XOR.should be_equal 2013
+  end
+
+  it 'op_implies should be equal 2014' do
+    OperatorKind::OP_IMPLIES.should be_equal 2014
+  end
+
+  it 'op_for_all should be equal 2015' do
+    OperatorKind::OP_FOR_ALL.should be_equal 2015
+  end
+
+  it 'op_exists should be equal 2016' do
+    OperatorKind::OP_EXISTS.should be_equal 2016
+  end
+
+  it 'op_plus should be equal 2020' do
+    OperatorKind::OP_PLUS.should be_equal 2020
+  end
+
+  it 'op_minus should be equal 2021' do
+    OperatorKind::OP_MINUS.should be_equal 2021
+  end
+
+  it 'op_multiply should be equal 2022' do
+    OperatorKind::OP_MULTIPLY.should be_equal 2022
+  end
+
+  it 'op_divide should be equal 2023' do
+    OperatorKind::OP_DIVIDE.should be_equal 2023
+  end
+
+  it 'op_exp should be equal 2024' do
+    OperatorKind::OP_EXP.should be_equal 2024
+  end
+
+  it '2000 should not be valid operator' do
+    OperatorKind.should_not be_valid_operator 2000
+  end
+
+  it '2001 should be valid operator' do
+    OperatorKind.should be_valid_operator 2001
+  end
+
+  it '2024 should be valid operator' do
+    OperatorKind.should be_valid_operator 2024
+  end
+
+  it '2025 should not be valid operator' do
+    OperatorKind.should_not be_valid_operator 2025
+  end
+
+  describe 'value should be assigned' do
+    before(:each) do
+      @operator_kind = OperatorKind.new(:value => 2001)
+    end
+
+    it 'value should be assigned' do
+      @operator_kind.value.should be_equal 2001
+    end
+
+    it 'should raise ArgumentError with invalid value' do
+      lambda {
+        @operator_kind.value = 10001
+      }.should raise_error ArgumentError
+    end
+  end
+end
+  
+    

data/spec/lib/open_ehr/am/archetype/constraint_model/archetype_constraint_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+
+describe ArchetypeConstraint do
+  before(:each) do
+    parent = stub(ArchetypeConstraint, :path => '/data/[at0001]')
+    @archetype_constraint =
+      ArchetypeConstraint.new(:path => '/data/events[at0003]/data/items[at0025]/value/magnitude',
+                              :parent => parent)
+  end
+
+  it 'should be an instance of ArchetypeConstraint' do
+    @archetype_constraint.should be_an_instance_of ArchetypeConstraint
+  end
+
+  it 'path should be assigned properly' do
+    @archetype_constraint.path.should == '/data/events[at0003]/data/items[at0025]/value/magnitude'
+  end
+
+  it 'should raise ArgumentError when path is not assigned' do
+    lambda {
+      @archetype_constraint.path = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'has_path? should return true if it has path' do
+    @archetype_constraint.should have_path 'events[at0003]'
+  end
+
+  it 'has_path? should return false if ti does not have path' do
+    @archetype_constraint.should_not have_path 'events[at0004]'
+  end
+
+  it 'parent should assigned properly' do
+    @archetype_constraint.parent.path.should == '/data/[at0001]'
+  end
+
+  it 'is congruent means this node starts from parent node' do
+    @archetype_constraint.should_not be_congruent
+  end
+
+  it 'is congruent when path starts with parent path' do
+    @archetype_constraint.path = '/data/[at0001]/test'
+    @archetype_constraint.should be_congruent
+  end
+
+  it 'node_conforms_to return true if path is follower' do
+    other = stub(ArchetypeConstraint, :path => '/data/events[at0003]')
+    @archetype_constraint.node_conforms_to?(other).should be_true
+  end
+
+  it 'node_conforms_to return false if path is other lineage' do
+    other = stub(ArchetypeConstraint, :path => '/event/')
+    @archetype_constraint.node_conforms_to?(other).should be_false
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/archetype_internal_ref_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe ArchetypeInternalRef do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    @archetype_internal_ref =
+      ArchetypeInternalRef.new(:path => '/event/[at0001]/',
+                               :rm_type_name => 'DV_TIME',
+                               :node_id => 'ac0001',
+                               :occurrences => occurrences,
+                               :target_path => '/data/[at0002]')
+  end
+
+  it 'should be an instance of ArchetypeInternalRef' do
+    @archetype_internal_ref.should be_an_instance_of ArchetypeInternalRef
+  end
+
+  it 'target_path should be assigned properly' do
+    @archetype_internal_ref.target_path.should == '/data/[at0002]'
+  end
+
+  it 'should raise ArgumentError when target_path is nil.' do
+    lambda {
+      @archetype_internal_ref.target_path = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when target_path is empty.' do
+    lambda {
+      @archetype_internal_ref.target_path = ''
+    }.should raise_error ArgumentError
+  end
+end
+  

data/spec/lib/open_ehr/am/archetype/constraint_model/archetype_slot_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe ArchetypeSlot do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    includes = stub(Set, :empty? => false, :size => 2)
+    excludes = stub(Set, :empty? => false, :size => 10)
+    @archetype_slot = ArchetypeSlot.new(:path => '/event/[at0001]/',
+                                        :rm_type_name => 'DV_TIME',
+                                        :node_id => 'ac0001',
+                                        :occurrences => occurrences,
+                                        :includes => includes,
+                                        :excludes => excludes)
+  end
+
+  it 'should be an instance of ArchetypeSlot' do
+    @archetype_slot.should be_an_instance_of ArchetypeSlot
+  end
+
+  it 'includes should be assigned properly' do
+    @archetype_slot.includes.size.should be_equal 2
+  end
+
+  it 'should raise ArgumentError when includes are empty' do
+    lambda {
+      @archetype_slot.includes = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'excludes should be assigned properly' do
+    @archetype_slot.excludes.size.should be_equal 10
+  end
+
+  it 'should raise ArgumentError when excludes are empty' do
+    lambda {
+      @archetype_slot.excludes = Set.new
+    }.should raise_error ArgumentError
+  end
+
+  it 'any_allowed should be false when includes and excludes are not nil' do
+    @archetype_slot.should_not be_any_allowed
+  end
+
+  it 'any_allowed should be false when includes are nil and excludes are not nil' do
+    @archetype_slot.includes = nil
+    @archetype_slot.should_not be_any_allowed
+  end
+
+  it 'any_allowed should be false when includes are not nil and excludes are nil' do
+    @archetype_slot.excludes = nil
+    @archetype_slot.should_not be_any_allowed
+  end
+
+  it 'any_allowed should be true when includes and excludes are nil' do
+    @archetype_slot.includes = nil
+    @archetype_slot.excludes = nil
+    @archetype_slot.should be_any_allowed
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_attribute_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CAttribute do
+  before(:each) do
+    existence = Interval.new(:lower => 0, :upper => 1)
+    children = stub(CObject, :rm_type_name => 'DV_AMOUNT')
+    @c_attribute = CAttribute.new(:path => '/event/[at0001]/',
+                                  :rm_attribute_name => 'DV_TEXT',
+                                  :existence => existence,
+                                  :children => children)
+  end
+
+  it 'should be an instance of CAttribute' do
+    @c_attribute.should be_an_instance_of CAttribute
+  end
+
+  it 'rm_attribute_name should be assigned properly' do
+    @c_attribute.rm_attribute_name.should == 'DV_TEXT'
+  end
+
+  it 'should raise ArguemntError rm_attribute_name is empty' do
+    lambda {
+      @c_attribute.rm_attribute_name = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError rm_attribute_name is nil' do
+    lambda {
+      @c_attribute.rm_attribute_name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'existence should be assigned properly' do
+    @c_attribute.existence.lower.should be_equal 0
+  end
+
+  it 'existence.lower should be more than 0' do
+    invalid_existence = Interval.new(:lower => -1, :upper => 1)
+    lambda {
+      @c_attribute.existence = invalid_existence
+    }.should raise_error ArgumentError
+  end
+
+  it 'existence.upper should be equal or less than 1' do
+    invalid_existence = Interval.new(:lower => 0, :upper => 2)
+    lambda {
+      @c_attribute.existence = invalid_existence
+    }.should raise_error ArgumentError
+  end
+
+  it 'children should be assigned properly' do
+    @c_attribute.children.rm_type_name.should == 'DV_AMOUNT'
+  end
+end
+
+
+

data/spec/lib/open_ehr/am/archetype/constraint_model/c_complex_object_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CComplexObject do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    parent = stub(CAttribute, :rm_attribute_name => 'DV_DATE')
+    attributes = stub(Set, :empty? => false, :size => 3)
+    @c_complex_object = CComplexObject.new(:path => '/event/[at0001]/',
+                                           :rm_type_name => 'DV_TIME',
+                                           :node_id => 'ac0001',
+                                           :occurrences => occurrences,
+                                           :attributes => attributes)
+  end
+
+  it 'should be an instance of CComplexObject' do
+    @c_complex_object.should be_an_instance_of CComplexObject
+  end
+
+  it 'attributes should be assigned properly' do
+    @c_complex_object.attributes.size.should be_equal 3
+  end
+
+  it 'any_allowed should be false when attributes are not empty' do
+    @c_complex_object.should_not be_any_allowed
+  end
+
+
+  it 'any_allowed should be true when attributes are nil' do
+    @c_complex_object.attributes = nil
+    @c_complex_object.should be_any_allowed
+  end
+
+  it 'any_allowed should be true when attributes are empty' do
+    @c_complex_object.attributes = Set.new
+    @c_complex_object.should be_any_allowed
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_defined_object_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CDefinedObject do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    parent = stub(CAttribute, :rm_attribute_name => 'DV_DATE')
+    @c_defined_object = CDefinedObject.new(:path => '/event/[at0001]/',
+                                           :rm_type_name => 'DV_TIME',
+                                           :node_id => 'ac0001',
+                                           :occurrences => occurrences,
+                                           :assumed_value => 'ANY')
+  end
+
+  it 'should be an instance of CDefinedObject' do
+    @c_defined_object.should be_an_instance_of CDefinedObject
+  end
+
+  it 'should be assigned properly' do
+    @c_defined_object.assumed_value.should == 'ANY'
+  end
+
+  it 'has_assumed_value should be true' do
+    @c_defined_object.should have_assumed_value
+  end
+
+  it 'has_assumed_value should not be true' do
+    @c_defined_object.assumed_value = nil
+    @c_defined_object.should_not have_assumed_value
+  end
+
+  it 'default_value should raise NotImplementedError' do
+    lambda {
+      @c_defined_object.default_value
+    }.should raise_error NotImplementedError
+  end
+
+  it 'valid_value should raise NotImplementedError' do
+    lambda {
+      @c_defined_object.valid_value?(1)
+    }.should raise_error NotImplementedError
+  end
+
+  it 'any_allowed should raise NotImplementedError' do
+    lambda {
+      @c_defined_object.any_allowed?
+    }.should raise_error NotImplementedError
+  end
+end
+
+
+

data/spec/lib/open_ehr/am/archetype/constraint_model/c_domain_type_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CDomainType do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    parent = stub(CAttribute, :rm_attribute_name => 'DV_DATE')
+    @c_domain_type = CDomainType.new(:path => '/event/[at0001]/',
+                                     :rm_type_name => 'DV_TIME',
+                                     :node_id => 'ac0001',
+                                     :occurrences => occurrences)
+  end
+
+  it 'should be an instance of CDomainType' do
+    @c_domain_type.should be_an_instance_of CDomainType
+  end
+
+  it 'standard_equivalent should raise NotImplementedError' do
+    lambda {
+      @c_domain_type.standard_equivalent
+    }.should raise_error NotImplementedError
+  end
+end
+                                           

data/spec/lib/open_ehr/am/archetype/constraint_model/c_multiple_attribute_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CMultipleAttribute do
+  before(:each) do
+    existence = Interval.new(:upper =>0, :lower => 0) 
+    cardinality = stub(Cardinality, :ordered? => true)
+    @c_multiple_attribute =
+      CMultipleAttribute.new(:path => '/event/at001',
+                             :rm_attribute_name => 'DV_DATE',
+                             :existence => existence,
+                             :cardinality => cardinality)
+  end
+
+  it 'should be an instance of CMulitipleAttribute' do
+    @c_multiple_attribute.should be_an_instance_of CMultipleAttribute
+  end
+
+  it 'cardinality should be assigned properly' do
+    @c_multiple_attribute.cardinality.should be_ordered
+  end
+
+  it 'should raise ArgumentError when cardinality is nil' do
+    lambda {
+      @c_multiple_attribute.cardinality = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_object_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CObject do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    parent = stub(CAttribute, :rm_attribute_name => 'DV_DATE')
+    @c_object = CObject.new(:path => '/event/[at0001]/',
+                            :rm_type_name => 'DV_TIME',
+                            :node_id => 'ac0001',
+                            :occurrences => occurrences,
+                            :parent => parent)
+  end
+
+  it 'should be an instance of CObject' do
+    @c_object.should be_an_instance_of CObject
+  end
+
+  it 'rm_type_name should be assigned properly' do
+    @c_object.rm_type_name.should == 'DV_TIME'
+  end
+
+  it 'should raise ArgumentError when rm_type_name was assigned nil' do
+    lambda {
+      @c_object.rm_type_name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when rm_type_name was assigned empty' do
+    lambda {
+      @c_object.rm_type_name = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'node_id should be assigned properly' do
+    @c_object.node_id.should == 'ac0001'
+  end
+
+  it 'should raise ArgumentError when node_id was assigned nil' do
+    lambda {
+      @c_object.node_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when node_id was assigned empty' do
+    lambda {
+      @c_object.node_id = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'occurences should be assigned properly' do
+    @c_object.occurrences.lower.should be_equal 0
+  end
+
+  it 'should raise ArgumentError when occurences was assigned nil' do
+    lambda {
+      @c_object.occurrences = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_primitive_object_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::AssumedLibraryTypes
+
+describe CPrimitiveObject do
+  before(:each) do
+    interval = Interval.new(:lower => 0, :upper => 1)
+    item = stub(CPrimitive, :node_id => 'at0001')
+    @c_primitive_object = CPrimitiveObject.new(:path => 'event/test',
+                                               :rm_type_name => 'DV_TEXT',
+                                               :node_id => 'ac0001',
+                                               :occurrences => interval,
+                                               :item => item)
+  end
+
+  it 'should be an instance of CPrimitiveObject' do
+    @c_primitive_object.should be_an_instance_of CPrimitiveObject
+  end
+
+  it 'item should be assigned properly' do
+    @c_primitive_object.item.node_id.should == 'at0001'
+  end
+
+  it 'should allowed any' do
+    @c_primitive_object.should_not be_any_allowed
+  end
+
+  it 'should not any allowed' do
+    @c_primitive_object.item = nil
+    @c_primitive_object.should be_any_allowed
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_reference_object_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CReferenceObject do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    @c_reference_object = CReferenceObject.new(:path => '/event/[at0001]/',
+                                               :rm_type_name => 'DV_TIME',
+                                               :node_id => 'ac0001',
+                                               :occurrences => occurrences)
+  end
+
+  it 'should be an instance of CReferenceObject' do
+    @c_reference_object.should be_an_instance_of CReferenceObject
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/c_single_attribute_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe CSingleAttribute do
+  before(:each) do
+    existence = Interval.new(:upper =>0, :lower => 0) 
+    alternatives = stub(Array, :size => 5)
+    @c_single_attribute = CSingleAttribute.new(:path => '/event/at001',
+                                              :rm_attribute_name => 'DV_DATE',
+                                              :existence => existence,
+                                              :alternatives => alternatives)
+  end
+
+  it 'should be an instance of CSingleAttribute' do
+    @c_single_attribute.should be_an_instance_of CSingleAttribute
+  end
+
+  it 'alternative should be assigned properly' do
+    @c_single_attribute.alternatives.size.should be_equal 5
+  end
+
+  it 'should raise ArgumentError when alternative is nil' do
+    lambda {
+      @c_single_attribute.alternatives = nil
+    }.should raise_error ArgumentError
+  end
+end