bonnie_bundler 2.0.0

data/test/simplecov_init.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+SimpleCov.command_name 'Unit Tests'
+SimpleCov.start do
+  add_filter "test/"
+  add_group "measures", "lib/measures"
+  add_group "models", "lib/models"
+end
+
+class SimpleCov::Formatter::QualityFormatter
+  def format(result)
+    SimpleCov::Formatter::HTMLFormatter.new.format(result)
+    File.open("coverage/covered_percent", "w") do |f|
+      f.puts result.source_files.covered_percent.to_f
+    end
+  end
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::QualityFormatter

data/test/test_helper.rb

@@ -0,0 +1,44 @@
+ENV["RAILS_ENV"] = "test"
+require_relative "./simplecov_init"
+require 'minitest/autorun'
+require 'rails'
+require 'rails/test_help'
+require 'hquery-patient-api'
+require 'diffy'
+APP_CONFIG = {'nlm'=> {'ticket_url'=> 'https://vsac.nlm.nih.gov/vsac/ws/Ticket',
+      'api_url' => 'https://vsac.nlm.nih.gov/vsac/svs/RetrieveMultipleValueSets',
+      'profiles_url' => 'https://vsac.nlm.nih.gov/vsac/profiles',
+      'profile' => 'MU2 Update 2016-04-01'}}
+
+PROJECT_ROOT = File.expand_path("../../", __FILE__)
+require File.join(PROJECT_ROOT, 'lib', 'bonnie_bundler')
+BonnieBundler.logger = Log4r::Logger.new("Bonnie Bundler")
+BonnieBundler.logger.outputters = Log4r::Outputter.stdout
+
+def dump_db
+  Mongoid.default_client.collections.each do |c|
+    c.drop()
+  end
+  FileUtils.rm_r 'db' if File.exists? 'db'
+end
+
+Mongoid.logger.level = Logger::INFO
+Mongo::Logger.logger.level = Logger::INFO
+dump_db
+
+# Supplied from bonnie, needed for expected_values testing
+class Record
+  field :type, type: String
+  field :measure_ids, type: Array
+  field :source_data_criteria, type: Array
+  field :expected_values, type: Array
+
+  belongs_to :user
+  scope :by_user, ->(user) { where({'user_id'=>user.id}) }
+end
+
+
+class User
+  include Mongoid::Document
+  include Mongoid::Timestamps
+end

data/test/unit/load_mat_export_test.rb

@@ -0,0 +1,181 @@
+require 'test_helper'
+require 'vcr_setup.rb'
+
+class LoadMATExportTest < ActiveSupport::TestCase
+
+  setup do
+    @cql_mat_export = File.new File.join('test', 'fixtures', 'BCS_v5_0_Artifacts.zip')
+    @cql_mat_5_4_export = File.new File.join('test', 'fixtures', 'CMS158_v5_4_Artifacts.zip')
+    @cql_multi_library_mat_export = File.new File.join('test', 'fixtures', 'bonnienesting01_fixed.zip')
+    @cql_draft_measure_mat_export = File.new File.join('test', 'fixtures', 'DRAFT_CMS2_CQL.zip')
+  end
+
+  test "Loading a CQL Mat export zip file including draft, with VSAC credentials" do
+    VCR.use_cassette("valid_vsac_response_includes_draft") do
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      overwrite_valuesets=false
+      cache=false
+      includeDraft=true
+      ticket_granting_ticket=nil
+      Measures::CqlLoader.load(@cql_draft_measure_mat_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD'], overwrite_valuesets, cache, includeDraft, ticket_granting_ticket).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal "Screening for Depression", measure.title
+      assert_equal "40280582-5B4D-EE92-015B-827458050128", measure.hqmf_id
+      assert_equal 1, measure.populations.size
+      assert_equal 5, measure.population_criteria.keys.count
+      assert_equal "C1EA44B5-B922-49C5-B41C-6509A6A86158", measure.hqmf_set_id
+      # Assert value_set versions are all "Draft-"
+      for value_set in measure.value_sets
+        assert_equal ("Draft-" + measure.hqmf_set_id), value_set["version"]
+      end
+    end
+  end
+
+  test "Using the cql-to-elm helper translation service" do
+    dump_db
+    user = User.new
+    user.save
+
+    VCR.use_cassette("valid_vsac_response") do
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+    end
+
+    VCR.use_cassette("valid_translation_response") do
+      measure = CqlMeasure.first
+      elm_json, elm_xml = CqlElm::CqlToElmHelper.translate_cql_to_elm(measure[:cql])
+      assert_equal 1, elm_json.count
+      assert_equal 1, elm_xml.count
+    end
+  end
+
+  test "Loading a CQL Mat export zip file, with VSAC credentials" do
+    VCR.use_cassette("valid_vsac_response") do
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal "BCSTest", measure.title
+      assert_equal "40280582-57B5-1CC0-0157-B53816CC0046", measure.hqmf_id
+      assert_equal 1, measure.populations.size
+      assert_equal 4, measure.population_criteria.keys.count
+    end
+  end
+
+  test "Loading a MAT 5.4 CQL export zip file with VSAC credentials" do
+    VCR.use_cassette("valid_vsac_response_158") do
+      dump_db
+      user = User.new
+      user.save
+
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_5_4_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal "Test 158", measure.title
+      assert_equal "40280582-5801-9EE4-0158-310E539D0327", measure.hqmf_id
+      assert_equal "8F010DBB-CB52-47CD-8FE8-03A4F223D87F", measure.hqmf_set_id
+      assert_equal 1, measure.populations.size
+      assert_equal 4, measure.population_criteria.keys.count
+      assert_equal 1, measure.elm.size
+    end
+  end
+
+  test "Loading a MAT 5.4 CQL export zip file with VSAC credentials, confirming cql measure package is stored" do
+    VCR.use_cassette("valid_vsac_response_158") do
+      dump_db
+      user = User.new
+      user.save
+
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_5_4_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal "Test 158", measure.title
+
+      assert_equal 1, CqlMeasurePackage.all.count
+      measure_package = CqlMeasurePackage.all.first
+      assert_equal measure.id, measure_package.measure_id
+    end
+  end
+
+  test "Loading a MAT 5.4 CQL export zip file with VSAC credentials, deleting measure and confirming measure package is also deleted" do
+    VCR.use_cassette("valid_vsac_response_158") do
+      dump_db
+      user = User.new
+      user.save
+
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_5_4_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal 1, CqlMeasurePackage.all.count
+
+      measure.delete
+      assert_equal 0, CqlMeasure.all.count
+      assert_equal 0, CqlMeasurePackage.all.count
+    end
+  end
+
+  test "Loading a CQL Mat export with multiple libraries, with VSAC credentials" do
+    VCR.use_cassette("multi_library_webcalls") do
+      dump_db
+      user = User.new
+      user.save
+
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_multi_library_mat_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal (measure.elm.instance_of? Array), true
+      assert_equal 4, measure.elm.size
+      measure.elm.each do |elm|
+        assert !(elm["library"].nil?)
+      end
+      assert_equal "BonnieLib100", measure.elm[0]["library"]["identifier"]["id"]
+      assert_equal "BonnieLib110", measure.elm[1]["library"]["identifier"]["id"]
+      assert_equal "BonnieLib200", measure.elm[2]["library"]["identifier"]["id"]
+      assert_equal "BonnieNesting01", measure.elm[3]["library"]["identifier"]["id"]
+    end
+  end
+
+  test "Scoping by user" do
+    dump_db
+    cql_mat_export = File.new File.join('test','fixtures','CMS158_v5_4_Artifacts.zip')
+    user = User.new
+    user2 = User.new
+    user2.save
+    VCR.use_cassette("valid_vsac_response_158") do
+      Measures::CqlLoader.load(cql_mat_export, user, {}).save
+    end
+
+    measure = CqlMeasure.all.by_user(user).first
+    # make sure that we can load a package and that the meause and valuesets are scoped to the user
+    assert_equal 1, CqlMeasure.all.by_user(user).count
+    vs_count = HealthDataStandards::SVS::ValueSet.count()
+    assert_equal vs_count, HealthDataStandards::SVS::ValueSet.by_user(user).count()
+    vs = HealthDataStandards::SVS::ValueSet.by_user(user).first
+    vsets = HealthDataStandards::SVS::ValueSet.by_user(user).to_a
+
+    # Add the same measure not associated with a user, there should be 2 measures and
+    # and twice as many value sets in the db after loading
+    VCR.use_cassette("valid_vsac_response_158") do
+      Measures::CqlLoader.load(cql_mat_export, user2, {}).save
+    end
+    measure2 = CqlMeasure.all.by_user(user2).first
+    assert_equal 1, CqlMeasure.by_user(user).count
+    assert_equal 2, CqlMeasure.count
+    assert_equal vs_count, HealthDataStandards::SVS::ValueSet.by_user(user).count()
+    assert_equal vs_count * 2, HealthDataStandards::SVS::ValueSet.count
+    u_count = Measures::ValueSetLoader.get_value_set_models(measure.value_set_oids, user).count()
+    assert_equal u_count, Measures::ValueSetLoader.get_value_set_models(measure2.value_set_oids, user2).count
+  end
+end

data/test/unit/measure_complexity_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class MeasureComplexityTest < ActiveSupport::TestCase
+
+  setup do
+    @cql_mat_export = File.new File.join('test', 'fixtures', 'BCS_v5_0_Artifacts.zip')
+  end
+
+  test "Loading a CQL Mat export zip file, with VSAC credentials" do
+    VCR.use_cassette("valid_vsac_response") do
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@cql_mat_export, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+      assert_equal 1, CqlMeasure.all.count
+      measure = CqlMeasure.all.first
+      assert_equal 10, measure.complexity["variables"].length
+      assert_equal [{"name"=>"Patient", "complexity"=>1},
+                    {"name"=>"SDE Ethnicity", "complexity"=>1},
+                    {"name"=>"SDE Payer", "complexity"=>1},
+                    {"name"=>"SDE Race", "complexity"=>1},
+                    {"name"=>"SDE Sex", "complexity"=>1},
+                    {"name"=>"Initial Pop", "complexity"=>2},
+                    {"name"=>"Num", "complexity"=>1},
+                    {"name"=>"Double Unilateral Mastectomy", "complexity"=>1},
+                    {"name"=>"Denom", "complexity"=>3},
+                    {"name"=>"Denom Excl", "complexity"=>2}], measure.complexity["variables"]
+    end
+  end
+
+end

data/test/unit/measure_diff_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'vcr_setup.rb'
+
+class MeasureDiffTest < ActiveSupport::TestCase
+
+  test "loading previous measure" do
+    VCR.use_cassette("valid_vsac_response_158") do
+      @previous_measure = File.new File.join('test','fixtures','CMS158_v5_4_Artifacts.zip')
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@previous_measure, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+    end
+    assert_equal 1, CqlMeasure.all.count
+    measure = CqlMeasure.all.first
+    assert_equal "Test 158", measure.title
+    assert_equal "40280582-5801-9EE4-0158-310E539D0327", measure.hqmf_id
+    assert_equal 1, measure.populations.size
+    assert_equal 4, measure.population_criteria.keys.count
+  end
+
+  test "loading updated measure" do
+    VCR.use_cassette("valid_vsac_response_158_update") do
+      @updated_measure = File.new File.join('test','fixtures','CMS158_v5_4_Artifacts_Update.zip')
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@updated_measure, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+    end
+    assert_equal 1, CqlMeasure.all.count
+    measure = CqlMeasure.all.first
+    assert_equal "Test 158 Update", measure.title
+    assert_equal "40280582-5801-9EE4-0158-310E539D0327", measure.hqmf_id
+    assert_equal 1, measure.populations.size
+    assert_equal 4, measure.population_criteria.keys.count
+  end
+
+  test "loading previous against updated" do
+    VCR.use_cassette("valid_vsac_response_158") do
+      @previous_measure = File.new File.join('test','fixtures','CMS158_v5_4_Artifacts.zip')
+      dump_db
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@previous_measure, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+    end
+    assert_equal 1, CqlMeasure.all.count
+    assert_equal 1, CqlMeasurePackage.all.count
+    previous = CqlMeasure.all.first
+    previous_package = CqlMeasurePackage.all.first
+    VCR.use_cassette("valid_vsac_response_158_update") do
+      @updated_measure = File.new File.join('test','fixtures','CMS158_v5_4_Artifacts_Update.zip')
+      user = User.new
+      user.save
+      measure_details = { 'episode_of_care'=> false }
+      Measures::CqlLoader.load(@updated_measure, user, measure_details, ENV['VSAC_USERNAME'], ENV['VSAC_PASSWORD']).save
+    end
+    assert_equal 2, CqlMeasure.all.count
+    assert_equal 2, CqlMeasurePackage.all.count
+    updated = CqlMeasure.order_by(created_at: :asc).last
+    updated_package = CqlMeasurePackage.order_by(created_at: :asc).last
+    assert_not_equal previous.title, updated.title
+    assert_not_equal previous_package.measure_id, updated_package.measure_id
+  end
+
+end

data/test/unit/mongo_hash_key_wrapper_test.rb

@@ -0,0 +1,247 @@
+require 'test_helper'
+
+class MongoHashKeyWrapperTest < ActiveSupport::TestCase
+
+  test "wrap does not modify key without dot or caret" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'bar'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( inputHash.key?('foo'))
+  end
+
+  test "wrap modifies key with dot" do
+    inputHash = Hash.new
+    inputHash['foo.baz'] = 'bar'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash.key?('foo.baz'))
+    assert( inputHash.key?('foo^pbaz'))
+  end
+
+  test "wrap does not modify value of key with dot" do
+    inputHash = Hash.new
+    inputHash['foo.baz'] = 'okay.text'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert_equal( 'okay.text', inputHash['foo^pbaz'])
+  end
+
+  test "wrap modifies key with caret" do
+    inputHash = Hash.new
+    inputHash['foo^baz'] = 'bar'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash.key?('foo^baz'))
+    assert( inputHash.key?('foo^cbaz'))
+  end
+
+  test "wrap does not modify value of key with caret" do
+    inputHash = Hash.new
+    inputHash['foo^baz'] = 'okay.text'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert_equal( 'okay.text', inputHash['foo^cbaz'])
+  end
+
+  test "wrap does not modify value without dot" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay text'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert_equal( 'okay text', inputHash['foo'])
+  end
+
+  test "wrap does not modify value with dot" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay.text'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert_equal( 'okay.text', inputHash['foo'])
+  end
+
+  test "wrap modifies all dots and carets in key" do
+    inputHash = Hash.new
+    inputHash['foo^baz.1.2^3^^^4..5bletch'] = 'bar'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash.key?('foo^baz.1.2^3^^^4..5bletch'))
+    assert( inputHash.key?('foo^cbaz^p1^p2^c3^c^c^c4^p^p5bletch'))
+  end
+
+  test "wrap modifies all keys in hash with dots or carets" do
+    inputHash = Hash.new
+    inputHash['one.foo'] = 'bar1'
+    inputHash['bletch'] = 'bar2'
+    inputHash['three.baz'] = 'bar3'
+    inputHash['four^zippo'] = 'bar4'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash.key?('one.foo'))
+    assert( !inputHash.key?('three.baz'))
+    assert( !inputHash.key?('four^zippo'))
+    assert( inputHash.key?('bletch'))
+    assert_equal( 'bar1', inputHash['one^pfoo'])
+    assert_equal( 'bar2', inputHash['bletch'])
+    assert_equal( 'bar3', inputHash['three^pbaz'])
+    assert_equal( 'bar4', inputHash['four^czippo'])
+  end
+
+  test "wrap modifies hash inside hash" do
+    inputHash = Hash.new
+    inputHash['foo'] = Hash.new
+    inputHash['foo']['fubar.baz'] = 'bar1'
+    inputHash['foo']['dos^tres'] = 'bar2'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash['foo'].key?('fubar.baz'))
+    assert( inputHash['foo'].key?('fubar^pbaz'))
+    assert( !inputHash['foo'].key?('dos^tres'))
+    assert( inputHash['foo'].key?('dos^ctres'))
+    assert_equal( 'bar1', inputHash['foo']['fubar^pbaz'])
+    assert_equal( 'bar2', inputHash['foo']['dos^ctres'])
+  end
+
+  test "wrap modifies hash inside modified hash" do
+    inputHash = Hash.new
+    inputHash['one.two'] = Hash.new
+    inputHash['one.two']['tres^quatro'] = 'bar'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert( !inputHash.key?('one.two'))
+    assert( inputHash.key?('one^ptwo'))
+    assert( !inputHash['one^ptwo'].key?('tres^quatro'))
+    assert( inputHash['one^ptwo'].key?('tres^cquatro'))
+    assert_equal( 'bar', inputHash['one^ptwo']['tres^cquatro'])
+  end
+
+  test "wrap modifies deeper hash" do
+    inputHash = Hash.new
+    inputHash['one'] = Hash.new
+    inputHash['one']['two'] = Hash.new
+    inputHash['one']['two']['three'] = Hash.new
+    inputHash['one']['two']['three']['four'] = Hash.new
+    inputHash['one']['two']['three']['four']['foo.bar^baz'] = 'bletch'
+    Measures::MongoHashKeyWrapper.wrapKeys(inputHash)
+    assert_equal( 'bletch', inputHash['one']['two']['three']['four']['foo^pbar^cbaz'])
+  end
+
+  ## wrap ---------------------------------------------------------------------------------
+
+  test "unwrap does not modify key without caret" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'bar'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( inputHash.key?('foo'))
+  end
+
+  test "unwrap modifies key with caret p" do
+    inputHash = Hash.new
+    inputHash['foo^pbaz'] = 'bar'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash.key?('foo^pbaz'))
+    assert( inputHash.key?('foo.baz'))
+  end
+
+  test "unwrap does not modify value of key with caret p" do
+    inputHash = Hash.new
+    inputHash['foo^pbaz'] = 'okay^ptext'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay^ptext', inputHash['foo.baz'])
+  end
+
+  test "unwrap modifies key with caret c" do
+    inputHash = Hash.new
+    inputHash['foo^cbaz'] = 'bar'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash.key?('foo^cbaz'))
+    assert( inputHash.key?('foo^baz'))
+  end
+
+  test "unwrap does not modify value of key with caret c" do
+    inputHash = Hash.new
+    inputHash['foo^cbaz'] = 'okay^ctext'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay^ctext', inputHash['foo^baz'])
+  end
+
+  test "unwrap does not modify value without caret" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay text'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay text', inputHash['foo'])
+  end
+
+  test "unwrap does not modify value with caret p" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay^ptext'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay^ptext', inputHash['foo'])
+  end
+
+  test "unwrap does not modify value with caret c" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay^ctext'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay^ctext', inputHash['foo'])
+  end
+
+  test "unwrap does not modify value with caret (other than p/c following)" do
+    inputHash = Hash.new
+    inputHash['foo'] = 'okay^text'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'okay^text', inputHash['foo'])
+  end
+
+  test "unwrap modifies all carets p's and c's in key" do
+    inputHash = Hash.new
+    inputHash['foo^cbaz^p1^p2^c3^c^c^c4^p^p5bletch'] = 'bar'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash.key?('foo^cbaz^p1^p2^c3^c^c^c4^p^p5bletch'))
+    assert( inputHash.key?('foo^baz.1.2^3^^^4..5bletch'))
+  end
+
+  test "unwrap modifies all keys in hash with all carets p's and c's" do
+    inputHash = Hash.new
+    inputHash['one^pfoo'] = 'bar1'
+    inputHash['bletch'] = 'bar2'
+    inputHash['three^pbaz'] = 'bar3'
+    inputHash['four^czippo'] = 'bar4'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash.key?('one^pfoo'))
+    assert( !inputHash.key?('three^pbaz'))
+    assert( !inputHash.key?('four^czippo'))
+    assert( inputHash.key?('bletch'))
+    assert_equal( 'bar1', inputHash['one.foo'])
+    assert_equal( 'bar2', inputHash['bletch'])
+    assert_equal( 'bar3', inputHash['three.baz'])
+    assert_equal( 'bar4', inputHash['four^zippo'])
+  end
+
+  test "unwrap modifies hash inside hash" do
+    inputHash = Hash.new
+    inputHash['foo'] = Hash.new
+    inputHash['foo']['fubar^pbaz'] = 'bar1'
+    inputHash['foo']['dos^ctres'] = 'bar2'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash['foo'].key?('fubar^pbaz'))
+    assert( inputHash['foo'].key?('fubar.baz'))
+    assert( !inputHash['foo'].key?('dos^ctres'))
+    assert( inputHash['foo'].key?('dos^tres'))
+    assert_equal( 'bar1', inputHash['foo']['fubar.baz'])
+    assert_equal( 'bar2', inputHash['foo']['dos^tres'])
+  end
+
+  test "unwrap modifies hash inside modified hash" do
+    inputHash = Hash.new
+    inputHash['one^ptwo'] = Hash.new
+    inputHash['one^ptwo']['tres^cquatro'] = 'bar'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert( !inputHash.key?('one^ptwo'))
+    assert( inputHash.key?('one.two'))
+    assert( !inputHash['one.two'].key?('tres^cquatro'))
+    assert( inputHash['one.two'].key?('tres^quatro'))
+    assert_equal( 'bar', inputHash['one.two']['tres^quatro'])
+  end
+
+  test "unwrap modifies deeper hash" do
+    inputHash = Hash.new
+    inputHash['one'] = Hash.new
+    inputHash['one']['two'] = Hash.new
+    inputHash['one']['two']['three'] = Hash.new
+    inputHash['one']['two']['three']['four'] = Hash.new
+    inputHash['one']['two']['three']['four']['foo^pbar^cbaz'] = 'bletch'
+    Measures::MongoHashKeyWrapper.unwrapKeys(inputHash)
+    assert_equal( 'bletch', inputHash['one']['two']['three']['four']['foo.bar^baz'])
+  end
+
+end