openehr 1.1.0

data/spec/lib/openehr/am/archetype/archetype_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+require 'set'
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AM::Archetype::Ontology
+include OpenEHR::RM::DataTypes::Text
+include OpenEHR::RM::Common::Resource
+include OpenEHR::RM::Support::Identification
+
+describe Archetype do
+  before(:each) do
+    original_language = stub(CodePhrase, :code_string => 'ja')
+    archetype_id = ArchetypeID.new(:value => 'openEHR-EHR-SECTION.physical_examination-prenatal.v2')
+    definition = stub(CComplexObject, :rm_type_name => 'SECTION')
+    items = {:text => 'Physical examination'}
+    term1 = ArchetypeTerm.new(:code => 'at0000', :items => items)
+    ontology = ArchetypeOntology.new(:specialisation_depth => 1, :term_definitions => {'ja' => {'at0000' =>term1}})
+    uid = HierObjectID.new(:value => 'ABCD::1')
+    parent_archetype_id = ArchetypeID.new(:value => 'openEHR-EHR-SECTION.physical_examination.v1')
+    invariants = stub(Set, :size => 2)
+    @archetype = Archetype.new(:original_language => original_language,
+                               :adl_version => '1.4',
+                               :archetype_id => archetype_id,
+                               :concept => 'at0000',
+                               :definition => definition,
+                               :ontology => ontology,
+                               :uid => uid,
+                               :parent_archetype_id => parent_archetype_id,
+                               :invariants => invariants)
+  end
+
+  it 'should be an instance of Archetype' do
+    @archetype.should be_an_instance_of Archetype
+  end
+
+  it 'adl_version should be assigned properly' do
+    @archetype.adl_version.should == '1.4'
+  end
+  
+  it 'archetype_id should be assigned prorperly' do
+    @archetype.archetype_id.value.should == 'openEHR-EHR-SECTION.physical_examination-prenatal.v2'
+  end
+
+  it 'should raise ArgumentError when archetype_id is nil' do
+    lambda {
+      @archetype.archetype_id = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'uid should be assigned properly' do
+    @archetype.uid.value.should == 'ABCD::1'
+  end
+
+  it 'concept should be assigned properly' do
+    @archetype.concept.should == 'at0000'
+  end
+
+  it 'should raise ArgumentError when concept is nil' do
+    lambda {
+      @archetype.concept = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'parent_archetype_id should be assigned properly' do
+    @archetype.parent_archetype_id.value.should == 'openEHR-EHR-SECTION.physical_examination.v1'
+  end
+
+  it 'definition should be assigned properly' do
+    @archetype.definition.rm_type_name.should == 'SECTION'
+  end
+
+  it 'should raise ArgumentError when definition is nil' do
+    lambda {
+      @archetype.definition = nil
+    }.should raise_error ArgumentError
+  end
+  
+  it 'ontology should be assigned properly' do
+    @archetype.ontology.specialisation_depth.should be_equal 1
+  end
+
+  it 'should raise ArgumentError when ontology is nil' do
+    lambda {
+      @archetype.ontology = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'invariants should be assigned properly' do
+    @archetype.invariants.size.should be_equal 2
+  end
+
+  it 'version should be extracted form id' do
+    @archetype.version.should == 'v2'
+  end
+
+  it 'short concept name should be extracted from archetype id' do
+    @archetype.short_concept_name.should == 'physical_examination'
+  end
+
+  it 'concept name should be extracted from ontology' do
+    @archetype.concept_name('ja').should == 'Physical examination'
+  end
+end

data/spec/lib/openehr/am/archetype/assertion/assertion_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe Assertion do
+  before(:each) do
+    expression = stub(ExprItem, :type => 'Boolean')
+    $string_expression = "/[at0001]/speed[at0002]/kilometres/magnitude = " +
+      "/[at0003]/speed[at0004]/miles/magnitude * 1.6"
+    variables = stub(Array, :size => 2)
+    @assertion = OpenEHR::AM::Archetype::Assertion::Assertion.new(:tag => 'validity',
+                               :expression => expression,
+                               :string_expression => $string_expression,
+                               :variables => variables)
+  end
+
+  it 'should be an instance of Assertion' do
+    @assertion.should be_an_instance_of OpenEHR::AM::Archetype::Assertion::Assertion
+  end
+
+  it 'expression should be assigned properly' do
+    @assertion.expression.type.should == 'Boolean'
+  end
+
+  it 'should raise ArgumentError when expression is nil' do
+    lambda {
+      @assertion.expression = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when expression type is not Boolean' do
+    invalid_expression = stub(ExprItem, :type => 'Real')
+    lambda {
+      @assertion.expression = invalid_expression
+    }.should raise_error ArgumentError
+  end
+
+  it 'tag should be assigned properly' do
+    @assertion.tag.should == 'validity'
+  end
+
+  it 'tag should not be empty' do
+    lambda {
+      @assertion.tag = ''
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError when tag = nil' do
+    lambda {
+      @assertion.tag = nil
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'string_expression should be assigned properly' do
+    @assertion.string_expression.should == $string_expression
+  end
+
+  it 'variables should be assigned properly' do
+    @assertion.variables.size.should be_equal 2
+  end
+end

data/spec/lib/openehr/am/archetype/assertion/assertion_variable_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe AssertionVariable do
+  before(:each) do
+    @assertion_variable =
+      AssertionVariable.new(:name => 'test',
+                            :definition => 'examine spec')
+  end
+
+  it 'name should be assigned properly' do
+    @assertion_variable.name.should == 'test'
+  end
+
+  it 'should raise ArgumentError when name is nil' do
+    lambda {
+      @assertion_variable.name = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'definition should be assigned properly' do
+    @assertion_variable.definition.should == 'examine spec'
+  end
+
+  it 'should raise ArgumentError if definiton is nil' do
+    lambda {
+      @assertion_variable.definition = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/am/archetype/assertion/expr_binary_operator.rb

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

data/spec/lib/openehr/am/archetype/assertion/expr_item_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprItem do
+  before(:each) do
+    @expr_item = ExprItem.new(:type => 'Real')
+  end
+
+  it 'should be an instance of ExprItem' do
+    @expr_item.should be_an_instance_of ExprItem
+  end
+
+  it 'type should be assigned properly' do
+    @expr_item.type.should == 'Real'
+  end
+
+  it 'should raise ArgumentError when type is nil' do
+    lambda {
+      @expr_item.type = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError when type is empty' do
+    lambda {
+      @expr_item.type = ''
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/am/archetype/assertion/expr_leaf_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprLeaf do
+  before(:each) do
+    @expr_leaf = ExprLeaf.new(:type => 'Boolean',
+                              :item => 'ANY',
+                              :reference_type => 'DV_TEXT')
+  end
+
+  it 'should be an instance of ExprLeaf' do
+    @expr_leaf.should be_an_instance_of ExprLeaf
+  end
+
+  it 'item should be assigned properly' do
+    @expr_leaf.item.should == 'ANY'
+  end
+
+  it 'should raise ArgumentError when item is nil' do
+    lambda {
+      @expr_leaf.item = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'reference_type should be assigned properly' do
+    @expr_leaf.reference_type.should == 'DV_TEXT'
+  end
+
+  it 'should raise ArgumentError when reference_type is nil' do
+    lambda {
+      @expr_leaf.reference_type = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/openehr/am/archetype/assertion/expr_operator_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::Assertion
+
+describe ExprOperator do
+  before(:each) do
+    operator = OperatorKind.new(:value => 2001)
+    @expr_operator = ExprOperator.new(:type => 'Integer',
+                                      :item => 'ANY',
+                                      :reference_type => 'operator',
+                                      :operator => operator,
+                                      :precedence_overridden => true)
+  end
+
+  it 'should be an instance of ExprOperator' do
+    @expr_operator.should be_an_instance_of ExprOperator
+  end
+
+  it 'operator should be assigned properly' do
+    @expr_operator.operator.value.should be_equal 2001
+  end
+
+  it 'precedence_overridden should be assigned properly' do
+    @expr_operator.precedence_overridden.should be_true
+  end
+end

data/spec/lib/openehr/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/openehr/am/archetype/assertion/operator_kind_spec.rb

@@ -0,0 +1,114 @@
+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_matches should be equal 2007' do
+    OperatorKind::OP_MATCHES.should be_equal 2007
+  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
+  
+