quality-measure-engine 1.1.1 → 1.1.2

data/Gemfile

@@ -7,7 +7,7 @@ gem 'bson_ext', '1.5.1',  :platforms => :mri
 gem 'rake'
 #gem 'pry', :require => true
 #gem 'health-data-standards', :git => 'https://github.com/projectcypress/health-data-standards.git', :branch => 'master'
-gem 'health-data-standards', '0.7.1'
+gem 'health-data-standards', '0.8.0'
 
 group :test do
   gem 'cover_me', '>= 1.0.0.rc5', :platforms => :ruby_19

data/lib/qme/ext/record.rb

@@ -1,49 +1,43 @@
 # Extensions to the Record model in health-data-standards to support
 # quality measure calculation
 class Record
-  extend ActiveSupport::Memoizable
-  
+
+  def procedures_performed
+    @procedures_performed = procedures.to_a + immunizations.to_a
+  end  
+
   def procedure_results
-    results.to_a + vital_signs.to_a + procedures.to_a
+    @procedure_results ||= results.to_a + vital_signs.to_a + procedures.to_a
   end
   
   def laboratory_tests
-    results.to_a + vital_signs.to_a
+    @laboratory_tests ||= results.to_a + vital_signs.to_a
   end
   
   def all_meds
-    medications.to_a + immunizations.to_a
+    @all_meds ||= medications.to_a + immunizations.to_a
   end
   
   def active_diagnosis
-    conditions.any_of({:status => 'active'}, {:status => nil}).to_a + 
+    @active_diagnosis ||= conditions.any_of({:status => 'active'}, {:status => nil}).to_a + 
     social_history.any_of({:status => 'active'}, {:status => nil}).to_a
   end
   
   def inactive_diagnosis
-    conditions.any_of({:status => 'inactive'}, {:status => nil}).to_a + 
+    @inactive_diagnosis ||= conditions.any_of({:status => 'inactive'}, {:status => nil}).to_a + 
     social_history.any_of({:status => 'inactive'}, {:status => nil}).to_a
   end
   
   def resolved_diagnosis
-    conditions.any_of({:status => 'resolved'}, {:status => nil}).to_a + 
+    @resolved_diagnosis ||= conditions.any_of({:status => 'resolved'}, {:status => nil}).to_a + 
     social_history.any_of({:status => 'resolved'}, {:status => nil}).to_a
   end
   
   def all_problems
-    conditions.to_a + social_history.to_a
+    @all_problems ||= conditions.to_a + social_history.to_a
   end
   
   def all_devices
-    conditions.to_a + procedures.to_a + care_goals.to_a + medical_equipment.to_a
+    @all_devices ||= conditions.to_a + procedures.to_a + care_goals.to_a + medical_equipment.to_a
   end
-  
-  memoize :procedure_results
-  memoize :laboratory_tests
-  memoize :all_meds
-  memoize :active_diagnosis
-  memoize :inactive_diagnosis
-  memoize :resolved_diagnosis
-  memoize :all_problems
-  memoize :all_devices
 end

data/lib/qme/importer/generic_importer.rb

@@ -44,10 +44,12 @@ module QME
         case standard_category
         when 'encounter'
           patient.encounters
+        when 'immunization'
+          patient.immunizations
         when 'procedure'
           case qds_data_type
           when 'procedure_performed'
-            patient.procedures
+            patient.procedures_performed
           when 'procedure_adverse_event', 'procedure_intolerance'
             patient.allergies
           when 'procedure_result'
@@ -60,7 +62,7 @@ module QME
         when 'laboratory_test'
           patient.laboratory_tests
         when 'physical_exam'
-          patient.vital_signs
+          patient.procedure_results
         when 'medication'
           case qds_data_type
           when 'medication_dispensed', 'medication_order', 'medication_active', 'medication_administered'

data/lib/qme/quality_measure.rb

@@ -18,6 +18,10 @@ module QME
       result
     end
     
+    def self.get_measures(measure_ids)
+      get_db.collection('measures').find('id' => {"$in" => measure_ids})
+    end
+    
     # Creates a new QualityMeasure
     # @param [String] measure_id value of the measure's id field
     # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator

data/lib/tasks/measure.rake

@@ -6,7 +6,6 @@ gem 'rubyzip'
 require 'zip/zip'
 require 'zip/zipfilesystem'
 require File.join(path,'../quality-measure-engine')
-
 measures_dir = ENV['MEASURE_DIR'] || 'measures'
 bundle_dir = ENV['BUNDLE_DIR'] || './'
 xls_dir = ENV['XLS_DIR'] || 'xls'
@@ -91,5 +90,21 @@ EOF
       file.close
     end
   end
+  
+  desc "export results of measures (expects date in YYYY-MM-DD format)"
+  task :export_results, :effective_date do |t, args|
+    measure_ids = ENV["MEASURES"].split(",")
+    measures = QME::QualityMeasure.get_measures(measure_ids)
+    effective_date_s = args[:effective_date] || "2010-12-31"
+    effective_date = Time.parse(effective_date_s).to_i
+    measures.each do |measure|
+      qr = QME::QualityReport.new(measure['id'], measure['sub_id'], 'effective_date' => effective_date)
+      qr.calculate(false) unless qr.calculated?
+      r = qr.result
+      
+      puts "#{measure['id']}#{measure['sub_id']}: #{r['numerator']}/#{r['denominator']}/#{r['population']} (#{r['exclusions']})"
+    end
+  end
+  
 
 end

data/spec/qme/bundle_spec.rb

@@ -0,0 +1,37 @@
+describe QME::MapReduce::Executor do
+
+  before :all do
+    @bundle_dir = File.join(File.dirname(__FILE__),'../../fixtures/bundle')
+    @measure_dir = 'measures'
+  end
+
+  before do
+    @loader = QME::Database::Loader.new('test')
+    @loader.get_db.drop_collection('measures')
+    @loader.get_db.drop_collection('bundles')
+  end
+  
+  it 'Should be able to load a bundle' do
+    bundle = @loader.save_bundle(@bundle_dir, @measure_dir)
+    bundle[:measures].length.should == 1
+    bundle[:bundle_data][:extensions].length.should == 3
+    bundle[:bundle_data]['name'].should == "test_bundle"
+    @loader.get_db['bundles'].count.should == 1
+    @loader.get_db['bundles'].find_one['name'].should == 'test_bundle'
+  end
+  
+  
+  it 'should be able to remove a bundle' do 
+    bundle = @loader.save_bundle(@bundle_dir, @measure_dir)
+    bundle_measures_count = bundle[:measures].length
+    @loader.get_db['bundles'].count.should == 1
+    measures = @loader.get_db['measures'].count
+    
+    @loader.remove_bundle(bundle[:bundle_data]['_id'])
+    @loader.get_db['bundles'].count.should == 0
+    measures = @loader.get_db['measures'].count.should == (measures - bundle_measures_count)
+    
+    
+  end
+  
+ end

data/spec/qme/importer/generic_importer_spec.rb

@@ -0,0 +1,73 @@
+describe QME::Importer::GenericImporter do
+
+  it "should properly handle devices" do
+    measure_def = {'measure' => {"cardiac_pacer" => {
+      "standard_category" => "device",
+      "qds_data_type" => "device_applied",
+      "type" => "array",
+      "items" => {
+        "type" => "number",
+        "format" => "utc-sec"
+      },
+      "codes" => [
+        {
+          "set" => "SNOMED-CT",
+          "values" => [
+            "14106009",
+            "56961003"
+          ]
+        }
+      ]
+    }}}
+    
+    entry = Entry.new
+    entry.add_code('14106009', 'SNOMED-CT')
+    entry.start_time = 1026777600
+    
+    patient = Record.new
+    patient.medical_equipment = [entry]
+    
+    gi = QME::Importer::GenericImporter.new(measure_def)
+    measure_info = gi.parse(patient)
+    measure_info['cardiac_pacer'].should include(1026777600)
+  end
+  
+  it "should handle active conditions" do
+    measure_def = {'measure' => {"silliness" => {
+      "standard_category" => "diagnosis_condition_problem",
+      "qds_data_type" => "diagnosis_active",
+      "type" => "array",
+      "items" => {
+        "type" => "number",
+        "format" => "utc-sec"
+      },
+      "codes" => [
+        {
+          "set" => "SNOMED-CT",
+          "values" => [
+            "14106009",
+            "56961003"
+          ]
+        }
+      ]
+    }}}
+    
+    entry1 = Entry.new
+    entry1.add_code('14106009', 'SNOMED-CT')
+    entry1.start_time = 1026777600
+    entry1.status = 'active'
+    
+    entry2 = Entry.new
+    entry2.add_code('14106009', 'SNOMED-CT')
+    entry2.start_time = 1026777601
+    entry2.status = 'inactive'
+    
+    patient = Record.new
+    patient.conditions = [entry1, entry2]
+    
+    gi = QME::Importer::GenericImporter.new(measure_def)
+    measure_info = gi.parse(patient)
+    measure_info['silliness'].should include(1026777600)
+    measure_info['silliness'].should_not include(1026777601)
+  end
+end

data/spec/qme/importer/measure_properties_generator_spec.rb

@@ -0,0 +1,15 @@
+describe QME::Importer::MeasurePropertiesGenerator do
+  it 'should generate measure properties' do
+      doc = Nokogiri::XML(File.new('fixtures/c32_fragments/0032/numerator.xml'))
+      doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
+
+      measure_json = JSON.parse(File.read(File.join('fixtures', 'entry', 'sample.json')))
+      QME::Importer::MeasurePropertiesGenerator.instance.add_measure('0043', QME::Importer::GenericImporter.new(measure_json))
+
+      patient = HealthDataStandards::Import::C32::PatientImporter.instance.parse_c32(doc)
+
+      measure_properties = QME::Importer::MeasurePropertiesGenerator.instance.generate_properties(patient)
+
+      measure_properties['0043']['encounter'].should include(1270598400)
+  end
+end

data/spec/qme/importer/property_matcher_spec.rb

@@ -0,0 +1,174 @@
+describe QME::Importer::PropertyMatcher do
+  
+  it "should raise an error when it can't determine the property schema" do
+    property_description = {
+      "type" => "cheese",
+      "description"  => "A cheesey example"
+    }
+    
+    pm = QME::Importer::PropertyMatcher.new(property_description)
+    expect {pm.match([])}.to raise_error
+  end
+  
+  it "should be able to extract a date list property" do
+    property_description = {
+      "type" => "array",
+      "items" =>  {
+        "type" => "number"
+      },
+      "codes" =>  [
+        {
+          "set" => "SNOMED-CT",
+          "values" => ["314443004"]
+        }
+      ]
+    }
+    
+    pm = QME::Importer::PropertyMatcher.new(property_description)
+    
+    entry = Entry.new
+    entry.add_code('314443004', 'SNOMED-CT')
+    entry.start_time = 1026777600
+    
+    result = pm.match([entry])
+    result.should include(1026777600)
+  end
+  
+
+  describe 'when extracting a date/value list property' do
+    it "should be able to deal with number values" do
+      property_description = {
+        "type" => "array",
+        "items" => {
+          "type" => "object",
+          "properties" => {
+            "value" => {
+              "type" => "number"
+            },
+            "date" =>  {
+              "type" => "number"
+            }
+          }
+        },
+        "codes" =>  [
+          {
+            "set" => "SNOMED-CT",
+            "values" => ["314443004"]
+          }
+        ]
+      }
+
+      pm = QME::Importer::PropertyMatcher.new(property_description)
+
+      entry = Entry.new
+      entry.add_code('314443004', 'SNOMED-CT')
+      entry.set_value('11.45')
+      entry.start_time = 1026777600
+
+      result = pm.match([entry])
+      result.should include({'date' => 1026777600, 'value' => 11.45})
+      result.length.should == 1
+    end
+    
+    it "should be able to deal with boolean values" do
+      property_description = {
+        "type" => "array",
+        "items" => {
+          "type" => "object",
+          "properties" => {
+            "value" => {
+              "type" => "boolean"
+            },
+            "date" =>  {
+              "type" => "number"
+            }
+          }
+        },
+        "codes" =>  [
+          {
+            "set" => "SNOMED-CT",
+            "values" => ["314443004"]
+          }
+        ]
+      }
+
+      pm = QME::Importer::PropertyMatcher.new(property_description)
+
+      entry = Entry.new
+      entry.add_code('314443004', 'SNOMED-CT')
+      entry.set_value('true')
+      entry.start_time = 1026777600
+
+      result = pm.match([entry])
+      result.should include({'date' => 1026777600, 'value' => true})
+      result.length.should == 1
+    end
+    
+    it "should be able to deal with string" do
+      property_description = {
+        "type" => "array",
+        "items" => {
+          "type" => "object",
+          "properties" => {
+            "value" => {
+              "type" => "string"
+            },
+            "date" =>  {
+              "type" => "number"
+            }
+          }
+        },
+        "codes" =>  [
+          {
+            "set" => "SNOMED-CT",
+            "values" => ["314443004"]
+          }
+        ]
+      }
+
+      pm = QME::Importer::PropertyMatcher.new(property_description)
+
+      entry = Entry.new
+      entry.add_code('314443004', 'SNOMED-CT')
+      entry.set_value('super critical')
+      entry.start_time = 1026777600
+
+      result = pm.match([entry])
+      result.should include({'date' => 1026777600, 'value' => 'super critical'})
+      result.length.should == 1
+    end
+  end
+
+  it "should be able to extract a date range property" do
+    property_description = {
+      "type" => "array",
+      "items" => {
+        "type" => "object",
+        "properties" => {
+          "start" => {
+            "type" => "number"
+          },
+          "end" =>  {
+            "type" => "number"
+          }
+        }
+      },
+      "codes" =>  [
+        {
+          "set" => "SNOMED-CT",
+          "values" => ["194774006"]
+        }
+      ]
+    }
+    
+    pm = QME::Importer::PropertyMatcher.new(property_description)
+
+    entry = Entry.new
+    entry.add_code('194774006', 'SNOMED-CT')
+    entry.start_time = 1026777600
+    entry.end_time = 1189814400
+    
+    result = pm.match([entry])
+    result.should include({'start' => 1026777600, 'end' => 1189814400})
+  end
+end

data/spec/qme/map/map_reduce_builder_spec.rb

@@ -0,0 +1,38 @@
+describe QME::MapReduce::Builder do
+  
+  before do
+    @loader = QME::Database::Loader.new('test')
+    raw_measure_json = File.read(File.join('fixtures', 'entry', 'sample.json'))
+    @measure_json = JSON.parse(raw_measure_json)
+  end
+
+  it 'should extract the measure metadata' do
+    measure = QME::MapReduce::Builder.new(@loader.get_db, @measure_json, 'effective_date'=>Time.gm(2010, 9, 19).to_i)
+    measure.id.should eql('0043')
+  end
+  it 'should extract one parameter for measure 0043' do
+    time = Time.gm(2010, 9, 19).to_i
+    measure = QME::MapReduce::Builder.new(@loader.get_db, @measure_json, 'effective_date'=>time)
+    measure.params.size.should eql(1)
+    measure.params.should have_key('effective_date')
+    measure.params['effective_date'].should eql(time)
+  end
+  it 'should raise a RuntimeError if not passed all the parameters' do
+    lambda { QME::MapReduce::Builder.new(@measure_json) }.should
+      raise_error(RuntimeError, 'No value supplied for measure parameter: effective_date')
+  end
+end
+
+describe QME::MapReduce::Builder::Context do
+  before do
+    @loader = QME::Database::Loader.new('test')
+  end 
+  
+  it 'should set instance methods from the supplied hash' do
+    vars = {'a'=>10, 'b'=>20}
+    context = QME::MapReduce::Builder::Context.new(@loader.get_db, vars)
+    binding = context.get_binding
+    eval("a",binding).should eql(10)
+    eval("b",binding).should eql(20)
+  end
+end

data/spec/qme/map/measures_spec.rb

@@ -0,0 +1,38 @@
+describe QME::MapReduce::Executor do
+
+  before do
+    @loader = QME::Database::Loader.new('test')
+    if ENV['MEASURE_DIR']
+      @measures = Dir.glob(File.join(ENV['MEASURE_DIR'], '*'))
+    else
+      @measures = Dir.glob(File.join('measures', '*'))
+    end
+
+    # define custom matchers
+    RSpec::Matchers.define :match_population do |population|
+      match do |value|
+        value == population
+      end
+    end
+    RSpec::Matchers.define :match_denominator do |denominator|
+      match do |value|
+        value == denominator
+      end
+    end
+    RSpec::Matchers.define :match_numerator do |numerator|
+      match do |value|
+        value == numerator
+      end
+    end
+    RSpec::Matchers.define :match_exclusions do |exclusions|
+      match do |value|
+        value == exclusions
+      end
+    end
+  end
+  
+  it 'should produce the expected results for each measure' do
+    validate_measures(@measures,@loader)
+  end
+  
+end

data/spec/qme/map/patient_mapper_spec.rb

@@ -0,0 +1,11 @@
+describe QME::MapReduce::Executor do
+
+  before do
+    @loader = QME::Database::Loader.new('test')
+  end
+  
+  it 'should map patients as expected' do
+    validate_patient_mapping(@loader)
+  end
+  
+end

data/spec/qme/measure_loader_spec.rb

@@ -0,0 +1,12 @@
+describe QME::Measure::Loader do
+  before do
+    @measure_def_dir = File.join('fixtures', 'measure_defs', 'sample_single_from_multi_xls')
+  end
+  
+  it 'Should load the sample measure correctly' do
+    measure = QME::Measure::Loader.load_measure(@measure_def_dir)
+    measure = measure[0]
+    measure['measure'].should have_key('eyes')
+    measure['measure'].should have_key('esrd_diagnosis_active')
+  end
+end

data/spec/qme/properties_builder_spec.rb

@@ -0,0 +1,61 @@
+require 'ap'
+
+describe QME::Measure::PropertiesBuilder do
+  before do
+    @json_file = File.join('fixtures', 'measure_props', 'props2.xlsx.json')
+    @properties = JSON.parse(File.read(@json_file))
+  end
+  
+  it 'Should patch the definition' do
+    @properties['N_1810']['value'].should be_nil
+    patched_properties = QME::Measure::PropertiesBuilder.patch_properties(@properties, @json_file)
+    patched_properties['N_1810']['value'].should have_key('type')
+    patched_properties['N_1472']['group_type'].should eql('abstract')
+  end
+  
+  it 'Should group properties' do
+    @properties.values.select { |value| value['standard_concept_id']=='N_c102' }.should_not be_empty
+    patched_properties = QME::Measure::PropertiesBuilder.patch_properties(@properties, @json_file)
+    grouped_properties = QME::Measure::PropertiesBuilder.build_groups(patched_properties)
+    grouped_properties.select { |key| key['standard_concept_id']=='N_c102' }.should be_empty
+    grouped_properties.select { |key| key['standard_concept_id']=='N_c190' }.should_not be_empty
+  end
+  
+  it 'Should create the expected properties' do
+    result = QME::Measure::PropertiesBuilder.build_properties(@properties, @json_file)
+    result['measure'].should have_key('diastolic_blood_pressure_physical_exam_finding')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding'].should have_key('standard_concept')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding']['standard_concept'].should eql('diastolic_blood_pressure')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding'].should have_key('standard_category')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding']['standard_category'].should eql('physical_exam')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding']['items']['type'].should eql('object')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding'].should have_key('codes')
+    result['measure']['diastolic_blood_pressure_physical_exam_finding']['codes'].length.should eql(1)
+    result['measure'].should have_key('encounter_outpatient_encounter')
+    result['measure']['encounter_outpatient_encounter']['items']['type'].should eql('number')
+    result['measure'].should have_key('esrd_diagnosis_active')
+    result['measure']['esrd_diagnosis_active']['standard_category'].should eql('diagnosis_condition_problem')
+    result['measure']['esrd_diagnosis_active']['codes'].length.should eql(3)
+  end
+  
+  it 'Should not create the excluded properties' do
+    result = QME::Measure::PropertiesBuilder.build_properties(@properties, @json_file)
+    result['measure'].select { |key| QME::Measure::PropertiesBuilder::PROPERTIES_TO_IGNORE.include?(key['standard_concept']) }.should be_empty
+  end
+
+  it 'Should expand code ranges for CPT codes' do
+    result = QME::Measure::PropertiesBuilder.extract_code_values("1, 2-5, 6 ", "SNOMED-CT")
+    result.length.should eql(3)
+    result.should include("1")
+    result.should include("2-5")
+    result.should include("6")
+    result = QME::Measure::PropertiesBuilder.extract_code_values("1, 2-5, 6 ", "CPT")
+    result.length.should eql(6)
+    result.should include("1")
+    result.should include("2")
+    result.should include("3")
+    result.should include("4")
+    result.should include("5")
+    result.should include("6")
+  end
+end

data/spec/qme/quality_report_spec.rb

@@ -0,0 +1,74 @@
+describe QME::QualityReport do
+  before do
+    loader = QME::Database::Loader.new
+    loader.drop_collection('query_cache')
+    loader.drop_collection('patient_cache')
+    loader.get_db['query_cache'].save(
+      "measure_id" => "test2",
+      "sub_id" =>  "b",
+      "initialPopulation" => 4,
+      "numerator" => 1,
+      "denominator" => 2,
+      "exclusions" => 1,
+      "effective_date" => Time.gm(2010, 9, 19).to_i
+    )
+    loader.get_db['patient_cache'].save(
+      "value" => {
+        "population" => false,
+        "denominator" => false,
+        "numerator" => false,
+        "exclusions" => false,
+        "antinumerator" => false,
+        "medical_record_id" => "0616911582",
+        "first" => "Mary",
+        "last" => "Edwards",
+        "gender" => "F",
+        "birthdate" => Time.gm(1940, 9, 19).to_i,
+        "test_id" => nil,
+        "provider_performances" => nil,
+        "race" => {
+          "code" => "2106-3",
+          "code_set" => "CDC-RE"
+        },
+        "ethnicity" => {
+          "code" => "2135-2",
+          "code_set" => "CDC-RE"
+        },
+        "measure_id" => "test2",
+        "sub_id" =>  "b",
+        "effective_date" => Time.gm(2010, 9, 19).to_i 
+      }
+    )
+  end
+  
+  it "should be able to determine if it has been calculated" do
+    qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 19).to_i)
+    qr.calculated?.should be_true
+    
+    qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 20).to_i)
+    qr.calculated?.should be_false
+  end
+  
+  it "should return the result of a calculated quality measure" do
+    qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 19).to_i)
+    result = qr.result
+    
+    result['numerator'].should == 1
+  end
+  
+  it "should be able to clear all of the quality reports" do
+    QME::QualityReport.destroy_all
+    
+    qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 19).to_i)
+    qr.calculated?.should be_false
+  end
+  
+  it "should be remove results for updated patients" do
+    qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 19).to_i)
+    qr.calculated?.should be_true
+    qr.patients_cached?.should be_true
+    QME::QualityReport.update_patient_results("0616911582")
+    qr.calculated?.should be_false
+    qr.patients_cached?.should be_false    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,120 @@
+begin
+  require 'cover_me'
+rescue LoadError
+  puts 'cover_me unavailable, running without code coverage measurement'
+end
+require 'bundler/setup'
+
+#require 'pry'
+
+PROJECT_ROOT = File.dirname(__FILE__) + '/../'
+
+require PROJECT_ROOT + 'lib/quality-measure-engine'
+
+Bundler.require(:test)
+ENV['DB_NAME'] = 'test'
+
+def reload_bundle(bundle_dir='.', measure_dir=ENV['MEASURE_DIR'] || 'measures')
+  loader = QME::Database::Loader.new
+  loader.drop_collection('bundles')
+  loader.drop_collection('measures')
+  loader.drop_collection('manual_exclusions')
+  loader.save_bundle(bundle_dir, measure_dir)
+  loader
+end
+
+def validate_measures(measure_dirs, loader)
+
+  reload_bundle
+
+  loader.get_db.collection('manual_exclusions').save({'measure_id'=>'test1', 'medical_record_id'=>'1234567890'})
+  
+  measure_dirs.each do |dir|
+    # check for sample data
+    fixture_dir = File.join('fixtures', 'measures', File.basename(dir))
+    patient_files = Dir.glob(File.join(fixture_dir, 'patients', '*.json'))
+    if patient_files.length==0
+      puts "Skipping #{dir}, no sample data in #{fixture_dir}"
+      next
+    end
+
+    puts "Parsing #{dir}"
+
+    loader.drop_collection('records')
+    loader.drop_collection('query_cache')
+    loader.drop_collection('patient_cache')
+    
+    # load measure from file system
+    # this is innefficient, could just load it from DB as its already stored there
+    measures = QME::Measure::Loader.load_measure(dir)
+    
+    # patients can include an optional test_id population identifier, extract this if present
+    test_id = nil
+    
+    # load db with sample patient records
+    patient_files.each do |patient_file|
+      patient = JSON.parse(File.read(patient_file))
+      test_id ||= patient['test_id']
+      loader.save('records', patient)
+    end
+      
+    # load expected results
+    result_file = File.join('fixtures', 'measures', File.basename(dir), 'result.json')
+    expected = JSON.parse(File.read(result_file))
+    
+    # evaulate measure using Map/Reduce and validate results
+    measures.each do |measure|
+      measure_id = measure['id']
+      sub_id = measure['sub_id']
+      puts "Validating measure #{measure_id}#{sub_id}"
+      executor = QME::MapReduce::Executor.new(measure_id, sub_id,
+        'effective_date'=>Time.gm(2010, 9, 19).to_i,
+        'test_id'=>test_id)
+      executor.map_records_into_measure_groups
+      result = executor.count_records_in_measure_groups
+      if expected['initialPopulation'] == nil
+        # multiple results for multi numerator/denominator measure
+        # loop through list of results to find the matching one
+        expected['results'].each do |expect|
+          if expect['id'].eql?(measure_id) && (sub_id==nil || expect['sub_id'].eql?(sub_id))
+            result['population'].should match_population(expect['initialPopulation'])
+            result['numerator'].should match_numerator(expect['numerator'])
+            result['denominator'].should match_denominator(expect['denominator'])
+            result['exclusions'].should match_exclusions(expect['exclusions'])
+            (result['numerator']+result['antinumerator']).should eql(expect['denominator'])
+            break
+          end
+        end
+      else
+        result['population'].should match_population(expected['initialPopulation'])
+        result['numerator'].should match_numerator(expected['numerator'])
+        result['denominator'].should match_denominator(expected['denominator'])
+        result['exclusions'].should match_exclusions(expected['exclusions'])
+        (result['numerator']+result['antinumerator']).should eql(expected['denominator'])
+      end
+    end
+    puts ' - done'
+  end
+  
+end
+
+def validate_patient_mapping(loader)
+  reload_bundle
+  loader.drop_collection('records')
+  loader.drop_collection('query_cache')
+  loader.drop_collection('patient_cache')
+  
+  patient_file = File.join('fixtures', 'mapping', 'test1_numerator.json')
+  patient = JSON.parse(File.read(patient_file))
+  loader.save('records', patient)
+
+  executor = QME::MapReduce::Executor.new('test1', nil,
+    'effective_date'=>Time.gm(2010, 9, 19).to_i)
+  result = executor.get_patient_result('patient1')
+
+  result['population'].should be(true)
+  result['numerator'].should be(true)
+  result['denominator'].should be(true)
+  result['exclusions'].should be(false)
+  result['antinumerator'].should be(false)
+end

data/spec/validate_measures_spec.rb

@@ -0,0 +1,21 @@
+# Validate the measure specifications and patient samples
+
+require 'json'
+
+describe JSON, 'All measure specifications' do
+  it 'should be valid JSON' do
+    Dir.glob(File.join('measures', '*', '*.json')).each do |measure_file|
+      measure = File.read(measure_file)
+      json = JSON.parse(measure)
+    end
+  end
+end
+
+describe JSON, 'All patient samples' do
+  it 'should be valid JSON' do
+    Dir.glob(File.join('fixtures', 'measures', '*', 'patients', '*.json')).each do |measure_file|
+      measure = File.read(measure_file)
+      json = JSON.parse(measure)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quality-measure-engine
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -11,12 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-17 00:00:00.000000000 -05:00
-default_executable: 
+date: 2012-05-10 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
-  requirement: &2157284660 !ruby/object:Gem::Requirement
+  requirement: &2158244120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -24,10 +23,10 @@ dependencies:
         version: '1.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2157284660
+  version_requirements: *2158244120
 - !ruby/object:Gem::Dependency
   name: rubyzip
-  requirement: &2157272260 !ruby/object:Gem::Requirement
+  requirement: &2158243320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -35,10 +34,10 @@ dependencies:
         version: 0.9.4
   type: :runtime
   prerelease: false
-  version_requirements: *2157272260
+  version_requirements: *2158243320
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2157271520 !ruby/object:Gem::Requirement
+  requirement: &2158242720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -46,10 +45,10 @@ dependencies:
         version: 1.4.4
   type: :runtime
   prerelease: false
-  version_requirements: *2157271520
+  version_requirements: *2158242720
 - !ruby/object:Gem::Dependency
   name: resque
-  requirement: &2157270840 !ruby/object:Gem::Requirement
+  requirement: &2158242260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -57,10 +56,10 @@ dependencies:
         version: 1.15.0
   type: :runtime
   prerelease: false
-  version_requirements: *2157270840
+  version_requirements: *2158242260
 - !ruby/object:Gem::Dependency
   name: resque-status
-  requirement: &2157270100 !ruby/object:Gem::Requirement
+  requirement: &2158235580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -68,10 +67,10 @@ dependencies:
         version: 0.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *2157270100
+  version_requirements: *2158235580
 - !ruby/object:Gem::Dependency
   name: jsonschema
-  requirement: &2157269380 !ruby/object:Gem::Requirement
+  requirement: &2158235040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -79,10 +78,10 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *2157269380
+  version_requirements: *2158235040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2157268580 !ruby/object:Gem::Requirement
+  requirement: &2158234480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -90,10 +89,10 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *2157268580
+  version_requirements: *2158234480
 - !ruby/object:Gem::Dependency
   name: awesome_print
-  requirement: &2157268080 !ruby/object:Gem::Requirement
+  requirement: &2158233760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -101,10 +100,10 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  version_requirements: *2157268080
+  version_requirements: *2158233760
 - !ruby/object:Gem::Dependency
   name: roo
-  requirement: &2157267620 !ruby/object:Gem::Requirement
+  requirement: &2158232780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -112,10 +111,10 @@ dependencies:
         version: 1.9.3
   type: :development
   prerelease: false
-  version_requirements: *2157267620
+  version_requirements: *2158232780
 - !ruby/object:Gem::Dependency
   name: builder
-  requirement: &2157267100 !ruby/object:Gem::Requirement
+  requirement: &2158231380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -123,10 +122,10 @@ dependencies:
         version: 3.0.0
   type: :development
   prerelease: false
-  version_requirements: *2157267100
+  version_requirements: *2158231380
 - !ruby/object:Gem::Dependency
   name: spreadsheet
-  requirement: &2157266420 !ruby/object:Gem::Requirement
+  requirement: &2158230480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -134,10 +133,10 @@ dependencies:
         version: 0.6.5.2
   type: :development
   prerelease: false
-  version_requirements: *2157266420
+  version_requirements: *2158230480
 - !ruby/object:Gem::Dependency
   name: google-spreadsheet-ruby
-  requirement: &2157265900 !ruby/object:Gem::Requirement
+  requirement: &2158229620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -145,7 +144,7 @@ dependencies:
         version: 0.1.2
   type: :development
   prerelease: false
-  version_requirements: *2157265900
+  version_requirements: *2158229620
 description: A library for extracting quality measure information from HITSP C32's
   and ASTM CCR's
 email: talk@projectpophealth.org
@@ -179,11 +178,22 @@ files:
 - lib/tasks/patient_random.rake
 - js/map_reduce_utils.js
 - js/underscore_min.js
+- spec/qme/bundle_spec.rb
+- spec/qme/importer/generic_importer_spec.rb
+- spec/qme/importer/measure_properties_generator_spec.rb
+- spec/qme/importer/property_matcher_spec.rb
+- spec/qme/map/map_reduce_builder_spec.rb
+- spec/qme/map/measures_spec.rb
+- spec/qme/map/patient_mapper_spec.rb
+- spec/qme/measure_loader_spec.rb
+- spec/qme/properties_builder_spec.rb
+- spec/qme/quality_report_spec.rb
+- spec/spec_helper.rb
+- spec/validate_measures_spec.rb
 - Gemfile
 - README.md
 - Rakefile
 - VERSION
-has_rdoc: true
 homepage: http://github.com/pophealth/quality-measure-engine
 licenses: []
 post_install_message: 
@@ -204,9 +214,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A library for extracting quality measure information from HITSP C32's and
   ASTM CCR's
 test_files: []
+has_rdoc: