fhir_models 1.6.3 → 1.6.4

data/test/unit/fluentpath/math_test.rb

@@ -1,62 +0,0 @@
-require_relative '../../test_helper'
-
-class MathTest < Test::Unit::TestCase
-
-  DATA = {
-    'x' => 7,
-    'y' => 3,
-    'foo' => 'a',
-    'bar' => 'b'
-  }
-
-  def test_plus_vars
-    result = FluentPath.evaluate('x + y',DATA)
-    assert result==10, 'Failed addition test.'
-  end
-
-  def test_plus_nums
-    result = FluentPath.evaluate('5 + 5',DATA)
-    assert result==10, 'Failed addition test.'
-  end
-
-  def test_plus_vars_strings
-    result = FluentPath.evaluate("foo + bar",DATA)
-    assert result=='ab', 'Failed addition test.'
-  end
-
-  def test_plus_strings
-    result = FluentPath.evaluate("'Joe' + ' ' + 'Smith'",DATA)
-    assert result=='Joe Smith', 'Failed addition test.'
-  end
-
-  def test_minus_vars
-    result = FluentPath.evaluate('x - y',DATA)
-    assert result==4, 'Failed subtraction test.'
-  end
-
-  def test_minus_nums
-    result = FluentPath.evaluate('5 - 1',DATA)
-    assert result==4, 'Failed subtraction test.'
-  end
-
-  def test_divide_vars
-    result = FluentPath.evaluate('x / y',DATA)
-    assert result==2, 'Failed division test.'
-  end
-
-  def test_divide_nums
-    result = FluentPath.evaluate('6 / 3',DATA)
-    assert result==2, 'Failed division test.'
-  end
-
-  def test_multiply_vars
-    result = FluentPath.evaluate('x * y',DATA)
-    assert result==21, 'Failed multiplication test.'
-  end
-
-  def test_multiply_nums
-    result = FluentPath.evaluate('6 * 3',DATA)
-    assert result==18, 'Failed multiplication test.'
-  end
-   
-end

data/test/unit/fluentpath/path_test.rb

@@ -1,118 +0,0 @@
-require_relative '../../test_helper'
-
-class PathTest < Test::Unit::TestCase
-
-  NAMES = ['Bob','Robert']
-  WTF = ['Bobert','Rob']
-  PID1 = 99
-  PATIENT = {
-    'name' => [{
-      'given' => NAMES
-    },{
-      'given' => WTF
-    }],
-    'resourceType' => 'Patient'
-  }
-  MESSAGE = {
-    'Message' => {
-      'PID-1' => PID1
-    }
-  }
-  ARRAY = {
-    'Array' => ['A','B'],
-    'index' => 1
-  }
-  ITEM = { 'base' => 'Patient' }
-  LIST = [5,4,3,2,1]
-
-  def test_path_without_type
-    result = FluentPath.evaluate('name.given',PATIENT)
-    assert result==NAMES+WTF, 'Failed to navigate path.'
-  end
-
-  def test_path_with_type
-    result = FluentPath.evaluate('Patient.name.given',PATIENT)
-    assert result==NAMES+WTF, 'Failed to navigate path.'
-  end
-
-  def test_path_conversion_2args
-    result = FluentPath.evaluate('Patient.name.given.select(substring(0,3))',PATIENT)
-    assert result==['Bob','Rob','Bob','Rob'], 'Failed to navigate path.'
-  end
-
-  def test_path_conversion_1args
-    result = FluentPath.evaluate('Patient.name.given.select(substring(1))',PATIENT)
-    assert result==['ob','obert','obert','ob'], 'Failed to navigate path.'
-  end
-
-  def test_path_with_quotes
-    result = FluentPath.evaluate('Message."PID-1"',MESSAGE)
-    assert result==PID1, 'Failed to navigate path.'
-  end
-
-  def test_array_access
-    result = FluentPath.evaluate('Array[0]',ARRAY)
-    assert result=='A', 'Failed to navigate path.'
-  end  
-
-  def test_array_access_with_variable
-    result = FluentPath.evaluate('Array[index]',ARRAY)
-    assert result=='B', 'Failed to navigate path.'
-  end
-
-  def test_children_first
-    expression = "children().element.first()"#.label.empty() and children().element.first().code.empty() and children().element.first().requirements.empty()"
-    data = {
-      'baseType' => 'Patient',
-      'snapshot' => {
-        'element' => [ITEM]
-      }
-    }
-    result = FluentPath.evaluate(expression,data)
-    assert result==ITEM, 'Failed to navigate children.'    
-  end
-
-  def test_first
-    expression = "list.first"
-    data = { 'list' => LIST }
-    result = FluentPath.evaluate(expression,data)
-    assert result==LIST.first, 'Failed to access first element.'
-  end
-
-  def test_last
-    expression = "list.last"
-    data = { 'list' => LIST }
-    result = FluentPath.evaluate(expression,data)
-    assert result==LIST.last, 'Failed to access last element.'
-  end
-
-  def test_tail
-    expression = "list.tail"
-    data = { 'list' => LIST }
-    result = FluentPath.evaluate(expression,data)
-    assert result==LIST.last(LIST.length-1), 'Failed to access tail elements.'
-  end
-
-  def test_count
-    expression = "list.count"
-    data = { 'list' => LIST }
-    result = FluentPath.evaluate(expression,data)
-    assert result==LIST.length, 'Failed to count elements.'
-  end
-
-  def test_parent
-    expression = "$parent.type='integer' or $parent.type='decimal'"
-    data = {}
-    parent = { 'type' => 'integer' }
-    result = FluentPath.evaluate(expression,data,parent)
-    assert result==true, 'Failed to access parent.'
-  end
-
-  def test_parent_nil
-    expression = "$parent.type='integer' or $parent.type='decimal'"
-    data = {}
-    result = FluentPath.evaluate(expression,data)
-    assert result==false, 'Failed to gracefully handle no $parent.'
-  end
-
-end

data/test/unit/fluentpath/string_test.rb

@@ -1,38 +0,0 @@
-require_relative '../../test_helper'
-
-class StringTest < Test::Unit::TestCase
-
-  DATA = {
-    'name' => 'John Doe',
-    'reference' => '#uri',
-    'uri' => 'http://snomed.ct'
-  }
-
-  # ------------------------- startsWith() -------------------------------------
-  def test_startsWith_true
-    result = FluentPath.evaluate("name.startsWith('John')",DATA)
-    assert result==true, 'Failed startsWith test.'
-  end
-
-  def test_startsWith_anchor
-    result = FluentPath.evaluate("reference.startsWith('#')",DATA)
-    assert result==true, 'Failed startsWith test.'
-  end
-
-  def test_startsWith_false
-    result = FluentPath.evaluate("name.startsWith('Zoo')",DATA)
-    assert result==false, 'Failed startsWith test.'
-  end
-
-  # ------------------------- contains() -------------------------------------
-  def test_contains_true
-    result = FluentPath.evaluate("name.contains('hn')",DATA)
-    assert result==true, 'Failed contains test.'
-  end
-
-  def test_contains_false
-    result = FluentPath.evaluate("name.contains('.')",DATA)
-    assert result==false, 'Failed contains test.'
-  end
-
-end

data/test/unit/json_format_test.rb

@@ -1,171 +0,0 @@
-require_relative '../test_helper'
-
-class JsonFormatTest < Test::Unit::TestCase
- 
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  ERROR_DIR = File.join('errors', 'JsonFormatTest')
-  ERROR_LOSSY_DIR = File.join('errors', 'JsonLossinessTest')
-  EXAMPLE_ROOT = File.join('examples','json')
-
-  # Automatically generate one test method per example file
-  example_files = File.join(EXAMPLE_ROOT, '**', '*.json')
-
-  # Create a blank folder for the errors
-  FileUtils.rm_rf(ERROR_DIR) if File.directory?(ERROR_DIR)
-  FileUtils.mkdir_p ERROR_DIR
-  FileUtils.rm_rf(ERROR_LOSSY_DIR) if File.directory?(ERROR_LOSSY_DIR)
-  FileUtils.mkdir_p ERROR_LOSSY_DIR
-
-  Dir.glob(example_files).each do | example_file |
-    example_name = File.basename(example_file, ".json")
-    define_method("test_json_format_#{example_name}") do
-      run_json_roundtrip_test(example_file, example_name)
-    end
-    define_method("test_json_xml_json_lossiness_#{example_name}") do
-      run_json_xml_json_lossiness_test(example_file, example_name)
-    end
-  end
-
-  def run_json_roundtrip_test(example_file, example_name)
-    input_json = File.read(example_file)
-    resource = FHIR::Json.from_json(input_json)
-    output_json = resource.to_json
-
-    input_hash = JSON.parse(input_json)
-    output_hash = JSON.parse(output_json)
-
-    errors = compare(input_hash,output_hash)
-
-    if !errors.empty?
-      File.open("#{ERROR_DIR}/#{example_name}.err", 'w:UTF-8') {|file| file.write(errors.join("\n"))}
-      File.open("#{ERROR_DIR}/#{example_name}_PRODUCED.json", 'w:UTF-8') {|file| file.write(output_json)}
-      File.open("#{ERROR_DIR}/#{example_name}_ORIGINAL.json", 'w:UTF-8') {|file| file.write(input_json)}      
-    end
-
-    assert errors.empty?, "Differences in generated JSON vs original"
-  end
-
-  def run_json_xml_json_lossiness_test(example_file, example_name)
-    input_json = File.read(example_file)
-    resource_from_json = FHIR::Json.from_json(input_json)
-    output_xml = resource_from_json.to_xml
-    resource_from_xml = FHIR::Xml.from_xml(output_xml)
-    output_json = resource_from_xml.to_json
-
-    input_hash = JSON.parse(input_json)
-    output_hash = JSON.parse(output_json)
-
-    errors = compare(input_hash,output_hash)
-
-    if !errors.empty?
-      File.open("#{ERROR_LOSSY_DIR}/#{example_name}.err", 'w:UTF-8') {|file| file.write(errors.join("\n"))}
-      File.open("#{ERROR_LOSSY_DIR}/#{example_name}_PRODUCED.xml", 'w:UTF-8') {|file| file.write(output_xml)}
-      File.open("#{ERROR_LOSSY_DIR}/#{example_name}_PRODUCED.json", 'w:UTF-8') {|file| file.write(output_json)}
-      File.open("#{ERROR_LOSSY_DIR}/#{example_name}_ORIGINAL.json", 'w:UTF-8') {|file| file.write(input_json)}      
-    end
-
-    assert errors.empty?, "Differences in generated JSON vs original"    
-  end
-
-  def compare(hash_input,hash_output)
-    return [hash_input] if hash_output.nil?
-
-    # ignore fhir comments -- we don't support them.
-    strip_out_unsupported!(hash_input)
-    strip_out_unsupported!(hash_output)
-
-    errors = []
-
-    added = hash_output.keys - hash_input.keys
-    errors << "Added extra fields: #{added.join(', ')}" if !added.empty?
-
-    dropped = hash_input.keys - hash_output.keys
-    errors << "Dropped fields: #{dropped.join(', ')}" if !dropped.empty?
-
-    shared_keys = hash_input.keys - dropped
-    shared_keys.each do |key|
-      input = hash_input[key]
-      output = hash_output[key]
-      if input.is_a?(Array) && !output.is_a?(Array)
-        errors << "#{key}:\n - INPUT:  #{input}\n - OUTPUT: #{output}"
-        next
-      end 
-      if output.is_a?(Array) && !input.is_a?(Array)
-        errors << "#{key}:\n - INPUT:  #{input}\n - OUTPUT: #{output}"
-        next
-      end
-      if input.is_a?(Array)
-        input.each_with_index do |item,index|
-          itemB = output[index]
-          if item.is_a?(Hash)
-            errors += compare(item,itemB)
-          elsif input!=output
-            errors << "#{key}[#{index}]: #{input} != #{output}"
-          end
-        end
-        errors << "#{key}:\n - INPUT:  #{input}\n - OUTPUT: #{output}" if input.size!=output.size
-      elsif input.is_a?(Hash)
-        errors += compare(input,output)
-      elsif is_a_date_or_time(input) || is_a_date_or_time(output)
-          # ignore date time formatting
-      elsif input!=output
-        errors << "#{key}:\n - INPUT:  #{input}\n - OUTPUT: #{output}"
-      end
-    end
-    errors
-  end
-
-  # This method removes fhir_comments and primitive extensions
-  # from the hash... we don't support them.
-  def strip_out_unsupported!(hash)
-    hash.each do |key,value|
-      delete_key = false
-      # delete fhir_comments and primitive extensions
-      if key=='fhir_comments' || key.start_with?('_')
-        delete_key = true
-      elsif value.is_a?(Array)
-        value.each do |thing|
-          strip_out_unsupported!(thing) if thing.is_a?(Hash)
-        end 
-      elsif value.is_a?(Hash)
-        strip_out_unsupported!(value)
-        delete_key = value.empty?
-      end
-      hash.delete(key) if delete_key
-    end
-  end
-
-  def is_a_date_or_time(value)
-    return false if !value.is_a?(String)
-
-    ['date','dateTime','time'].each do |type|
-      meta = FHIR::PRIMITIVES[type]
-      expression = meta['regex']
-      regex = Regexp.new(expression)
-      return true if !(regex =~ value).nil?
-    end
-
-    # when 'instant'
-    regex = /-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))))/
-    return true if !(regex =~ value).nil?
-
-    false
-
-    # # when 'instant'
-    # regex = /-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00)))))/
-    # return true if !(regex =~ value).nil?
-    # # when 'date'
-    # regex = /-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1])))/
-    # return true if !(regex =~ value).nil?        
-    # # when 'datetime'
-    # regex = /-?[0-9]{4}(-(0[1-9]|1[0-2])(-(0[0-9]|[1-2][0-9]|3[0-1])(T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?)?)?)?/
-    # return true if !(regex =~ value).nil?
-    # # when 'time'
-    # regex = /([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?/
-    # return true if !(regex =~ value).nil?
-    # false
-  end
-
-end

data/test/unit/json_validation_test.rb

@@ -1,36 +0,0 @@
-require_relative '../test_helper'
-
-class JsonValidationTest < Test::Unit::TestCase
- 
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  ERROR_DIR = File.join('errors', 'JsonValidationTest')
-  EXAMPLE_ROOT = File.join('examples','json')
-
-  # Automatically generate one test method per example file
-  example_files = File.join(EXAMPLE_ROOT, '**', '*.json')
-
-  # Create a blank folder for the errors
-  FileUtils.rm_rf(ERROR_DIR) if File.directory?(ERROR_DIR)
-  FileUtils.mkdir_p ERROR_DIR
-
-  Dir.glob(example_files).each do | example_file |
-    example_name = File.basename(example_file, ".json")
-    define_method("test_json_validation_#{example_name}") do
-      run_json_validation_test(example_file, example_name)
-    end
-  end
-
-  def run_json_validation_test(example_file, example_name)
-    input_json = File.read(example_file)
-    resource = FHIR::Json.from_json(input_json)
-    errors = resource.validate
-    if !errors.empty?
-      File.open("#{ERROR_DIR}/#{example_name}.err", 'w:UTF-8') {|file| file.write(JSON.pretty_unparse(errors))}
-      File.open("#{ERROR_DIR}/#{example_name}.json", 'w:UTF-8') {|file| file.write(input_json)}      
-    end
-    assert errors.empty?, "Resource failed to validate."
-  end
-
-end

data/test/unit/multiple_types_test.rb

@@ -1,76 +0,0 @@
-require_relative '../test_helper'
-
-class MultipleTypesTest < Test::Unit::TestCase
-
-  # turn off the ridiculous warnings
-  $VERBOSE=nil
-
-  # move this flag around multiple types and assert that it is found in the correct place
-  FLAG = 123
-
-  def test_multiple_types
-    obs = FHIR::Observation.new
-
-    obs.effectiveDateTime = '2016-04-19'
-    assert (obs.effective == obs.effectiveDateTime), "Observation.effective did not return effectiveDateTime"
-    obs.effectiveDateTime = nil
-
-    obs.effectivePeriod = FHIR::Period.new
-    assert (obs.effective == obs.effectivePeriod), "Observation.effective did not return effectivePeriod"
-
-    obs.valueQuantity = FLAG
-    assert (obs.value == obs.valueQuantity), "Observation.value did not return valueQuantity"
-    obs.valueQuantity = nil
-
-    obs.valueCodeableConcept = FLAG
-    assert (obs.value == obs.valueCodeableConcept), "Observation.value did not return valueCodeableConcept"
-    obs.valueCodeableConcept = nil
-
-    obs.valueString = FLAG
-    assert (obs.value == obs.valueString), "Observation.value did not return valueString"
-    obs.valueString = nil
-
-    obs.valueRange = FLAG
-    assert (obs.value == obs.valueRange), "Observation.value did not return valueRange"
-    obs.valueRange = nil
-
-    obs.valueRatio = FLAG
-    assert (obs.value == obs.valueRatio), "Observation.value did not return valueRatio"
-    obs.valueRatio = nil
-
-    obs.valueSampledData = FLAG
-    assert (obs.value == obs.valueSampledData), "Observation.value did not return valueSampledData"
-    obs.valueSampledData = nil
-
-    obs.valueAttachment = FLAG
-    assert (obs.value == obs.valueAttachment), "Observation.value did not return valueAttachment"
-    obs.valueAttachment = nil
-
-    obs.valueTime = FLAG
-    assert (obs.value == obs.valueTime), "Observation.value did not return valueTime"
-    obs.valueTime = nil
-
-    obs.valueDateTime = FLAG
-    assert (obs.value == obs.valueDateTime), "Observation.value did not return valueDateTime"
-    obs.valueDateTime = nil
-
-    obs.valuePeriod = FLAG
-    assert (obs.value == obs.valuePeriod), "Observation.value did not return valuePeriod"
-  end
-
-  def test_non_existing_multiple_types
-    obs = FHIR::Observation.new
-    assert ((obs.foo rescue FLAG)==FLAG), "Observation.foo should not exist"
-  end
-
-  def test_multiple_cardinality
-    obs = FHIR::Observation.new
-    FHIR::Observation::METADATA.each do |key,meta|
-      if meta['max'] > 1
-        value = obs.instance_variable_get("@#{key}".to_sym)
-        assert((!value.nil? && value.is_a?(Array) && value.empty?), "Observation.#{key} should be an empty Array.")
-      end
-    end
-  end
-
-end