quality-measure-engine 2.1.0 → 2.2.0

data/lib/qme/bundle/bundle.rb

@@ -31,15 +31,18 @@ module QME
       original.split('/').last.gsub(".#{extension}", '')
     end
     
-    def self.unpack_bundle_contents(zip)
+    def self.unpack_bundle_contents(zip, type = nil)
       bundle_contents = { bundle: nil, measures: {}, patients: {}, extensions: {}, results: {} }
       Zip::ZipFile.open(zip.path) do |zipfile|
         zipfile.entries.each do |entry|
           bundle_contents[:bundle] = zipfile.read(entry.name) if entry.name.include? "bundle"
-          bundle_contents[:measures][Bundle.entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^measures.*\.json$/
-          bundle_contents[:patients][Bundle.entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^patients.*\.json$/ # Only need to import one of the formats
+          if type.nil? || entry.name.match(Regexp.new("/#{type}/")) 
+            bundle_contents[:measures][Bundle.entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^measures.*\.json$/
+            bundle_contents[:patients][Bundle.entry_key(entry.name, "json")] = zipfile.read(entry.name) if entry.name.match /^patients.*\.json$/ # Only need to import one of the formats
+            bundle_contents[:results][Bundle.entry_key(entry.name,"json")] = zipfile.read(entry.name) if entry.name.match /^results.*\.json/
+          end
           bundle_contents[:extensions][Bundle.entry_key(entry.name,"js")] = zipfile.read(entry.name) if entry.name.match /^library_functions.*\.js/
-          bundle_contents[:results][Bundle.entry_key(entry.name,"json")] = zipfile.read(entry.name) if entry.name.match /^results.*\.json/
+
         end
       end
       bundle_contents

data/lib/qme/bundle/eh_measure_sheet.rb

@@ -22,16 +22,17 @@ module QME
         qc_document.merge!(measure_ids)
         extract_patients(measure_ids)
 
-        qc_document['population'] = extract_data_from_cell("C#{@population_totals_row}")
-        qc_document['considered'] = @population_totals_row - 3 # header row, blank row and totals row
+        qc_document[QME::QualityReport::POPULATION] = extract_data_from_cell("C#{@population_totals_row}")
+        qc_document[QME::QualityReport::CONSIDERED] = @population_totals_row - 3 # header row, blank row and totals row
         if cv_measure?
-          qc_document['msrpopl'] = extract_data_from_cell("E#{@population_totals_row}")
+          qc_document[QME::QualityReport::MSRPOPL] = extract_data_from_cell("E#{@population_totals_row}")
+          qc_document[QME::QualityReport::OBSERVATION] = extract_data_from_cell("F#{@population_totals_row}")
         else
-          qc_document['denominator'] = extract_data_from_cell("D#{@population_totals_row}")
-          qc_document['numerator'] = extract_data_from_cell("E#{@population_totals_row}")
-          qc_document['antinumerator'] = qc_document['denominator'] - qc_document['numerator']
-          qc_document['exclusions'] = extract_data_from_cell("F#{@population_totals_row}")
-          qc_document['denexcep'] = extract_data_from_cell("G#{@population_totals_row}")
+          qc_document[QME::QualityReport::DENOMINATOR] = extract_data_from_cell("D#{@population_totals_row}")
+          qc_document[QME::QualityReport::NUMERATOR] = extract_data_from_cell("E#{@population_totals_row}")
+          qc_document[QME::QualityReport::ANTINUMERATOR] = qc_document[QME::QualityReport::DENOMINATOR] - qc_document[QME::QualityReport::NUMERATOR]
+          qc_document[QME::QualityReport::EXCLUSIONS] = extract_data_from_cell("F#{@population_totals_row}")
+          qc_document[QME::QualityReport::EXCEPTIONS] = extract_data_from_cell("G#{@population_totals_row}")
         end
 
         qc_document['test_id'] = nil
@@ -60,16 +61,17 @@ module QME
 
       def extract_measure_info
         measure_info = {}
-        measure_info['IPP'] = extract_data_from_cell('I5')
+        measure_info[QME::QualityReport::POPULATION] = extract_data_from_cell('I5')
         if cv_measure?
-          measure_info['MSRPOPL'] = extract_data_from_cell('I10')
-          measure_info['stratification'] = extract_data_from_cell('I11') if extract_data_from_cell('I11').present?
+          measure_info[QME::QualityReport::MSRPOPL] = extract_data_from_cell('I10')
+          measure_info[QME::QualityReport::OBSERVATION] = extract_data_from_cell('I11') if extract_data_from_cell('I11').present?
+          measure_info['stratification'] = extract_data_from_cell('I12') if extract_data_from_cell('I12').present?
         else
           measure_info['DENOM'] = extract_data_from_cell('I6')
           measure_info['NUMER'] = extract_data_from_cell('I7')
           measure_info['DENEXCEP'] = extract_data_from_cell('I8') if extract_data_from_cell('I8').present?
           measure_info['DENEX'] = extract_data_from_cell('I9') if extract_data_from_cell('I9').present?
-          measure_info['stratification'] = extract_data_from_cell('I11') if extract_data_from_cell('I11').present?
+          measure_info['stratification'] = extract_data_from_cell('I12') if extract_data_from_cell('I12').present?
         end
 
         measure_info
@@ -81,15 +83,16 @@ module QME
                                               'ethnicity', 'languages')
         patient_document['medical_record_id'] = medical_record_number
         patient_document['patient_id'] = record['_id'].to_s
-        patient_document['population'] = extract_data_from_cell("C#{row}") || 0
+        patient_document[QME::QualityReport::POPULATION] = extract_data_from_cell("C#{row}") || 0
         if cv_measure?
-          patient_document['values'] = [extract_data_from_cell("E#{row}")]
+          patient_document[QME::QualityReport::MSRPOPL] = extract_data_from_cell("E#{row}") || 0
+          patient_document['values'] = [extract_data_from_cell("F#{row}")]
         else
-          patient_document['denominator'] = extract_data_from_cell("D#{row}") || 0
-          patient_document['numerator'] = extract_data_from_cell("E#{row}") || 0
-          patient_document['exclusions'] = extract_data_from_cell("F#{row}") || 0
-          patient_document['denexcep'] = extract_data_from_cell("G#{row}") || 0
-          patient_document['antinumerator'] = patient_document['denominator'] - patient_document['numerator']
+          patient_document[QME::QualityReport::DENOMINATOR] = extract_data_from_cell("D#{row}") || 0
+          patient_document[QME::QualityReport::NUMERATOR] = extract_data_from_cell("E#{row}") || 0
+          patient_document[QME::QualityReport::EXCLUSIONS] = extract_data_from_cell("F#{row}") || 0
+          patient_document[QME::QualityReport::EXCEPTIONS] = extract_data_from_cell("G#{row}") || 0
+          patient_document[QME::QualityReport::ANTINUMERATOR] = patient_document[QME::QualityReport::DENOMINATOR] - patient_document[QME::QualityReport::NUMERATOR]
 
         end
         patient_document['test_id'] = nil

data/lib/qme/bundle/eh_patient_importer.rb

@@ -6,8 +6,12 @@ module QME
           ms = EHMeasureSheet.new(db, worksheet, effective_date)
           ms.parse
           qc_document = ms.query_cache_document
+          db['query_cache'].find({measure_id: qc_document['measure_id'], sub_id: qc_document['sub_id']}).remove
+          db.command(getLastError: 1)
           db['query_cache'].insert(qc_document)
           ms.patient_cache_documents.each do |pcd|
+            db['patient_cache'].find({'value.measure_id'=>pcd['value']['measure_id'], 'value.sub_id'=>pcd['value']['sub_id'],'value.medical_record_id'=>pcd['value']['medical_record_id']}).remove
+            db.command(getLastError: 1)
             db['patient_cache'].insert(pcd)
           end
           ms.patient_updates.each do |patient_update|

data/lib/qme/bundle/importer.rb

@@ -13,12 +13,13 @@ module QME
       # Import a quality bundle into the database. This includes metadata, measures, test patients, supporting JS libraries, and expected results.
       #
       # @param [File] zip The bundle zip file.
+      # @param [String] Type of measures to import, either 'ep', 'eh' or nil for all
       # @param [Boolean] keep_existing If true, delete all current collections related to patients and measures.
-      def import(zip, delete_existing)
+      def import(zip,  delete_existing, type=nil)
         Bundle.drop_collections(@db) if delete_existing
         
         # Unpack content from the bundle.
-        bundle_contents = QME::Bundle.unpack_bundle_contents(zip)
+        bundle_contents = QME::Bundle.unpack_bundle_contents(zip, type)
 
         # Store all JS libraries.
         bundle_contents[:extensions].each do |key, contents|

data/lib/qme/map/map_reduce_executor.rb

@@ -20,32 +20,66 @@ module QME
         determine_connection_information()
       end
 
+      def build_query
+        pipeline = []
+
+        filters = @parameter_values['filters']
+
+        
+        match = {'value.measure_id'       => @measure_id, 
+         'value.sub_id'           => @sub_id,
+         'value.effective_date'   => @parameter_values['effective_date'],
+         'value.test_id'          => @parameter_values['test_id'],
+         'value.manual_exclusion' => {'$in' => [nil, false]}}
+
+        if(filters)
+          if (filters['races'] && filters['races'].size > 0)
+            match['value.race.code'] = {'$in' => filters['races']}
+          end
+          if (filters['ethnicities'] && filters['ethnicities'].size > 0)
+            match['value.ethnicity.code'] = {'$in' => filters['ethnicities']}
+          end
+          if (filters['genders'] && filters['genders'].size > 0)
+            match['value.gender'] = {'$in' => filters['genders']}
+          end
+          if (filters['providers'] && filters['providers'].size > 0)
+            providers = filters['providers'].map { |pv| {'providers' => Moped::BSON::ObjectId(pv) } }
+            pipeline.concat [{'$project' => {'value' => 1, 'providers' => "$value.provider_performances.provider_id"}}, 
+                             {'$unwind' => '$providers'}, 
+                             {'$match' => {'$or' => providers}},
+                             {'$group' => {"_id" => "$_id", "value" => {"$first" => "$value"}}}]
+          end
+          if (filters['languages'] && filters['languages'].size > 0)
+            languages = filters['languages'].map { |l| {'languages' => l } }
+            pipeline.concat  [{'$project' => {'value' => 1, 'languages' => "$value.languages"}},
+                              {'$unwind' => "$languages"},
+                              {'$project' => {'value' => 1, 'languages' => {'$substr' => ['$languages', 0, 2]}}},
+                              {'$match' => {'$or' => languages}},
+                              {'$group' => {"_id" => "$_id", "value" => {"$first" => "$value"}}}]
+          end
+        end
+
+        pipeline.unshift({'$match' => match})
+
+        pipeline
+      end
+
       # Examines the patient_cache collection and generates a total of all groups
       # for the measure. The totals are placed in a document in the query_cache
       # collection.
       # @return [Hash] measure groups (like numerator) as keys, counts as values
       def count_records_in_measure_groups
-        pipeline = []
-        base_query = {'value.measure_id' => @measure_id, 'value.sub_id' => @sub_id,
-                      'value.effective_date' => @parameter_values['effective_date'],
-                      'value.test_id' => @parameter_values['test_id']}
-
-        base_query.merge!(filter_parameters)
-        
-        query = base_query.clone
-
-        query.merge!({'value.manual_exclusion' => {'$in' => [nil, false]}})
+        pipeline = build_query
 
-        pipeline << {'$match' => query}
         pipeline << {'$group' => {
           "_id" => "$value.measure_id", # we don't really need this, but Mongo requires that we group 
-          "population" => {"$sum" => "$value.population"}, 
-          "denominator" => {"$sum" => "$value.denominator"},
-          "numerator" => {"$sum" => "$value.numerator"},
-          "antinumerator" => {"$sum" => "$value.antinumerator"},
-          "exclusions" => {"$sum" => "$value.exclusions"},
-          "denexcep" => {"$sum" => "$value.denexcep"},
-          "considered" => {"$sum" => 1}
+          QME::QualityReport::POPULATION => {"$sum" => "$value.#{QME::QualityReport::POPULATION}"}, 
+          QME::QualityReport::DENOMINATOR => {"$sum" => "$value.#{QME::QualityReport::DENOMINATOR}"},
+          QME::QualityReport::NUMERATOR => {"$sum" => "$value.#{QME::QualityReport::NUMERATOR}"},
+          QME::QualityReport::ANTINUMERATOR => {"$sum" => "$value.#{QME::QualityReport::ANTINUMERATOR}"},
+          QME::QualityReport::EXCLUSIONS => {"$sum" => "$value.#{QME::QualityReport::EXCLUSIONS}"},
+          QME::QualityReport::EXCEPTIONS => {"$sum" => "$value.#{QME::QualityReport::EXCEPTIONS}"},
+          QME::QualityReport::CONSIDERED => {"$sum" => 1}
         }}
         
         aggregate = get_db.command(:aggregate => 'patient_cache', :pipeline => pipeline)
@@ -62,7 +96,7 @@ module QME
 
         result.merge!(aggregate['result'].first)
         result.reject! {|k, v| k == '_id'} # get rid of the group id the Mongo forced us to use
-        result['exclusions'] += get_db['patient_cache'].find(base_query.merge({'value.manual_exclusion'=>true})).count
+        # result['exclusions'] += get_db['patient_cache'].find(base_query.merge({'value.manual_exclusion'=>true})).count
         result.merge!(execution_time: (Time.now.to_i - @parameter_values['start_time'].to_i)) if @parameter_values['start_time']
         get_db()["query_cache"].insert(result)
         get_db().command({:getLastError => 1}) # make sure last insert finished before we continue
@@ -123,37 +157,6 @@ module QME
         get_db()['patient_cache'].find({'value.measure_id'=>@measure_id, 'value.sub_id'=>@sub_id, 'value.medical_record_id'=>{'$in'=>exclusions} })
           .update_all({'$set'=>{'value.manual_exclusion'=>true}})
       end
-
-      def filter_parameters
-        results = {}
-        conditions = []
-        if(filters = @parameter_values['filters'])
-          if (filters['providers'] && filters['providers'].size > 0)
-            providers = filters['providers'].map {|provider_id| Moped::BSON::ObjectId(provider_id) if (provider_id and provider_id != 'null') }
-            # provider_performances have already been filtered by start and end date in map_reduce_builder as part of the finalize
-            conditions << {'value.provider_performances.provider_id' => {'$in' => providers}}
-          end
-          if (filters['races'] && filters['races'].size > 0)
-            conditions << {'value.race.code' => {'$in' => filters['races']}}
-          end
-          if (filters['ethnicities'] && filters['ethnicities'].size > 0)
-            conditions << {'value.ethnicity.code' => {'$in' => filters['ethnicities']}}
-          end
-          if (filters['genders'] && filters['genders'].size > 0)
-            conditions << {'value.gender' => {'$in' => filters['genders']}}
-          end
-          if (filters['languages'] && filters['languages'].size > 0)
-            languages = filters['languages'].clone
-            has_unspecified = languages.delete('null')
-            or_clauses = []
-            or_clauses << {'value.languages'=>{'$regex'=>Regexp.new("(#{languages.join("|")})-..")}} if languages.length > 0
-            or_clauses << {'value.languages'=>nil} if (has_unspecified)
-            conditions << {'$or'=>or_clauses}
-          end
-        end
-        results.merge!({'$and'=>conditions}) if conditions.length > 0
-        results
-      end
     end
   end
 end

data/lib/qme/map/measure_calculation_job.rb

@@ -33,7 +33,7 @@ module QME
           
           tick('Calculating group totals')
           result = map.count_records_in_measure_groups
-          completed("#{@measure_id}#{@sub_id}: p#{result['population']}, d#{result['denominator']}, n#{result['numerator']}, excl#{result['exclusions']}, excep#{result['denexcep']}")
+          completed("#{@measure_id}#{@sub_id}: p#{result[QME::QualityReport::POPULATION]}, d#{result[QME::QualityReport::DENOMINATOR]}, n#{result[QME::QualityReport::NUMERATOR]}, excl#{result[QME::QualityReport::EXCLUSIONS]}, excep#{result[QME::QualityReport::EXCEPTIONS]}")
         end
       end
 

data/lib/qme/quality_measure.rb

@@ -21,6 +21,14 @@ module QME
     def self.get_measures(measure_ids)
       get_db()['measures'].find('id' => {"$in" => measure_ids})
     end
+
+    def self.get(measure_id, sub_id)
+      get_db()['measures'].find('id' => measure_id, 'sub_id' => sub_id)
+    end
+
+    def self.sub_measures(measure_id)
+      get_db()['measures'].find('id' => measure_id)
+    end
     
     # Creates a new QualityMeasure
     # @param [String] measure_id value of the measure's id field

data/lib/qme/quality_report.rb

@@ -1,11 +1,23 @@
 module QME
+  
   # A class that allows you to create and obtain the results of running a
   # quality measure against a set of patient records.
   class QualityReport
+    
     include DatabaseAccess
     extend DatabaseAccess
     determine_connection_information
 
+    POPULATION = 'IPP'
+    DENOMINATOR = 'DENOM'
+    NUMERATOR = 'NUMER'
+    EXCLUSIONS = 'DENEX'
+    EXCEPTIONS = 'DENEXCEP'
+    MSRPOPL = 'MSRPOPL'
+    OBSERVATION = 'OBSERV'
+    ANTINUMERATOR = 'antinumerator'
+    CONSIDERED = 'considered'
+
     # Gets rid of all calculated QualityReports by dropping the patient_cache
     # and query_cache collections
     def self.destroy_all

data/lib/qme/tasks/bundle.rake

@@ -4,19 +4,19 @@ db_name = ENV['DB_NAME'] || 'test'
 
 namespace :bundle do
   desc 'Import a quality bundle into the database.'
-  task :import, [:bundle_path, :delete_existing] => [:environment] do |task, args|
+  task :import, [:bundle_path,  :delete_existing, :type] => [:environment] do |task, args|
     raise "The path to the measures zip file must be specified" unless args.bundle_path
 
     bundle = File.open(args.bundle_path)    
     importer = QME::Bundle::Importer.new(db_name)
-    bundle_contents = importer.import(bundle, args.delete_existing == "true")
+    bundle_contents = importer.import(bundle,  args.delete_existing == "true", args.type)
     
     puts "Successfully imported bundle at: #{args.bundle_path}"
     puts "\t Imported into environment: #{Rails.env.upcase}" if defined? Rails 
+    puts "\t Loaded #{args.type || "all"} measures"
     puts "\t Measures Loaded: #{bundle_contents[:measures].count}"
     puts "\t Test Patients Loaded: #{bundle_contents[:patients].count}"
     puts "\t Extensions Loaded: #{bundle_contents[:extensions].count}"
-    
   end
   
   # this task is most likely temporary.  Once Bonnie can handle both EP and EH measures together, this would no longer be required.
@@ -68,11 +68,13 @@ namespace :bundle do
       ['measures','patients','extensions'].each do |key|
         json_out[key] = (json_one[key] + json_two[key]).uniq
       end
+      
+      version = json_out['version']
 
       File.open(File.join(tmpdir,'output','bundle.json'), 'w') {|f| f.write(JSON.pretty_generate(json_out)) }
       date_string = Time.now.strftime("%Y-%m-%d")
 
-      out_zip = File.join('tmp','bundles',"bundle-merged-#{date_string}.zip")
+      out_zip = File.join('tmp','bundles',"bundle-merged-#{date_string}-#{version}.zip")
       FileUtils.remove_entry_secure out_zip if File.exists?(out_zip)
       Zip::ZipFile.open(out_zip, 'w') do |zipfile|
         path = File.join(tmpdir,'output')

data/lib/qme/version.rb

@@ -1,3 +1,3 @@
 module QME
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

data/test/unit/qme/bundle/eh_measure_sheet_test.rb

@@ -21,16 +21,16 @@ class EHMeasureSheetTest < MiniTest::Unit::TestCase
     @ms.parse
     qcd = @ms.query_cache_document
     assert_equal '0142', qcd['nqf_id']
-    assert_equal 4, qcd['population']
+    assert_equal 4, qcd[QME::QualityReport::POPULATION]
     assert_equal 12345000, qcd['effective_date']
   end
 
   def test_patient_cache_documents
     @ms.parse
     pcd = @ms.patient_cache_documents.first
-    assert_equal 1, pcd['value']['population']
-    assert_equal 0, pcd['value']['numerator']
-    assert_equal 1, pcd['value']['antinumerator']
+    assert_equal 1, pcd['value'][QME::QualityReport::POPULATION]
+    assert_equal 0, pcd['value'][QME::QualityReport::NUMERATOR]
+    assert_equal 1, pcd['value'][QME::QualityReport::ANTINUMERATOR]
     assert_equal '1234', pcd['value']['medical_record_id']
     assert_equal 12345000, pcd['value']['effective_date']
   end

data/test/unit/qme/map/map_reduce_executor_test.rb

@@ -5,7 +5,7 @@ class MapReduceExecutorTest < MiniTest::Unit::TestCase
 
   def setup
     importer = QME::Bundle::Importer.new
-    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'), true)
+    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'), true, nil)
 
     collection_fixtures(get_db(), 'records', '_id')
   end
@@ -13,13 +13,14 @@ class MapReduceExecutorTest < MiniTest::Unit::TestCase
   def test_map_records_into_measure_groups
     executor = QME::MapReduce::Executor.new("2E679CD2-3FEC-4A75-A75A-61403E5EFEE8", nil,
                                             'effective_date' => Time.gm(2011, 1, 15).to_i)
+                                            
     executor.map_records_into_measure_groups
 
     assert_equal 4, get_db['patient_cache'].find().count
-    assert_equal 3, get_db['patient_cache'].find('value.population' => 1).count
-    assert_equal 1, get_db['patient_cache'].find('value.population' => 0).count
-    assert_equal 2, get_db['patient_cache'].find('value.denominator' => 1).count
-    assert_equal 1, get_db['patient_cache'].find('value.numerator' => 1).count
+    assert_equal 3, get_db['patient_cache'].find("value.#{QME::QualityReport::POPULATION}" => 1).count
+    assert_equal 1, get_db['patient_cache'].find("value.#{QME::QualityReport::POPULATION}" => 0).count
+    assert_equal 2, get_db['patient_cache'].find("value.#{QME::QualityReport::DENOMINATOR}" => 1).count
+    assert_equal 1, get_db['patient_cache'].find("value.#{QME::QualityReport::NUMERATOR}" => 1).count
   end
 
   def test_count_records_in_measure_groups
@@ -29,9 +30,9 @@ class MapReduceExecutorTest < MiniTest::Unit::TestCase
     executor.count_records_in_measure_groups
     assert_equal 1, get_db['query_cache'].find().count
     doc = get_db['query_cache'].find().first
-    assert_equal 3, doc['population']
-    assert_equal 2, doc['denominator']
-    assert_equal 1, doc['numerator']
+    assert_equal 3, doc[QME::QualityReport::POPULATION]
+    assert_equal 2, doc[QME::QualityReport::DENOMINATOR]
+    assert_equal 1, doc[QME::QualityReport::NUMERATOR]
   end
 
   def test_map_record_into_measure_groups
@@ -40,10 +41,10 @@ class MapReduceExecutorTest < MiniTest::Unit::TestCase
     executor.map_record_into_measure_groups("12345")
 
     assert_equal 1, get_db['patient_cache'].find().count
-    assert_equal 1, get_db['patient_cache'].find('value.population' => 1).count
-    assert_equal 0, get_db['patient_cache'].find('value.population' => 0).count
-    assert_equal 1, get_db['patient_cache'].find('value.denominator' => 1).count
-    assert_equal 1, get_db['patient_cache'].find('value.numerator' => 1).count
+    assert_equal 1, get_db['patient_cache'].find("value.#{QME::QualityReport::POPULATION}" => 1).count
+    assert_equal 0, get_db['patient_cache'].find("value.#{QME::QualityReport::POPULATION}" => 0).count
+    assert_equal 1, get_db['patient_cache'].find("value.#{QME::QualityReport::DENOMINATOR}" => 1).count
+    assert_equal 1, get_db['patient_cache'].find("value.#{QME::QualityReport::NUMERATOR}" => 1).count
   end
 
   def test_get_patient_result
@@ -51,6 +52,6 @@ class MapReduceExecutorTest < MiniTest::Unit::TestCase
                                             'effective_date' => Time.gm(2011, 1, 15).to_i)
     result = executor.get_patient_result("12345")
     assert_equal 0, get_db['patient_cache'].find().count
-    assert result['numerator']
+    assert result[QME::QualityReport::NUMERATOR]
   end
 end

data/test/unit/qme/map/measure_calculation_job_test.rb

@@ -5,7 +5,7 @@ class MapCalculationJobTest < MiniTest::Unit::TestCase
 
   def setup
     importer = QME::Bundle::Importer.new
-    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'), true)
+    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'),  true, nil)
 
     collection_fixtures(get_db(), 'records', '_id')
 

data/test/unit/qme/quality_measure_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class QualityMeasureTest < MiniTest::Unit::TestCase
   def setup
     importer = QME::Bundle::Importer.new
-    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'), true)
+    importer.import(File.new('test/fixtures/bundles/just_measure_0002.zip'), true,nil)
   end
 
   def test_getting_all_measures

data/test/unit/qme/quality_report_test.rb

@@ -10,18 +10,18 @@ class QualityReportTest < MiniTest::Unit::TestCase
       "measure_id" => "test2",
       "sub_id" =>  "b",
       "initialPopulation" => 4,
-      "numerator" => 1,
-      "denominator" => 2,
-      "exclusions" => 1,
+      QME::QualityReport::NUMERATOR => 1,
+      QME::QualityReport::DENOMINATOR => 2,
+      QME::QualityReport::EXCLUSIONS => 1,
       "effective_date" => Time.gm(2010, 9, 19).to_i
     )
     get_db()['patient_cache'].insert(
       "value" => {
-        "population" => false,
-        "denominator" => false,
-        "numerator" => false,
-        "exclusions" => false,
-        "antinumerator" => false,
+        QME::QualityReport::POPULATION => 0,
+        QME::QualityReport::DENOMINATOR => 0,
+        QME::QualityReport::NUMERATOR => 0,
+        QME::QualityReport::EXCLUSIONS => 0,
+        QME::QualityReport::ANTINUMERATOR => 0,
         "medical_record_id" => "0616911582",
         "first" => "Mary",
         "last" => "Edwards",
@@ -57,7 +57,7 @@ class QualityReportTest < MiniTest::Unit::TestCase
     qr = QME::QualityReport.new('test2', 'b', "effective_date" => Time.gm(2010, 9, 19).to_i)
     result = qr.result
     
-    assert_equal 1, result['numerator']
+    assert_equal 1, result[QME::QualityReport::NUMERATOR]
   end
   
   def test_destroy_all

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quality-measure-engine
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2012-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moped