marty 2.5.2 → 2.5.4

data/spec/models/config_spec.rb

@@ -2,68 +2,68 @@ require 'spec_helper'
 
 module Marty
   describe Marty::Config do
-    describe "validations" do
-      it "should return valid config value based on key" do
-        Marty::Config["TEST 1"] = 2
-        expect(Marty::Config.lookup("TEST 1")).to eq(2)
-        expect(Marty::Config["TEST 1"]).to eq(2)
+    describe 'validations' do
+      it 'should return valid config value based on key' do
+        Marty::Config['TEST 1'] = 2
+        expect(Marty::Config.lookup('TEST 1')).to eq(2)
+        expect(Marty::Config['TEST 1']).to eq(2)
       end
 
       def testval(val)
-        Marty::Config["testval"] = val
-        expect(Marty::Config.lookup("testval")).to eq(val)
-        expect(Marty::Config["testval"]).to eq(val)
+        Marty::Config['testval'] = val
+        expect(Marty::Config.lookup('testval')).to eq(val)
+        expect(Marty::Config['testval']).to eq(val)
       end
 
       def testval_fail(val)
-        expect{testval(val)}.to raise_error(ActiveRecord::RecordInvalid,
-                                            'Validation failed: bad JSON value')
+        expect { testval(val) }.to raise_error(ActiveRecord::RecordInvalid,
+                                               'Validation failed: bad JSON value')
       end
 
-      it "should handle various structures correctly" do
-        testval("[1,2,3]")
-        testval("[1,\"2,3\"]")
-        testval([1,2,3])
-        testval([1,"2,3"])
+      it 'should handle various structures correctly' do
+        testval('[1,2,3]')
+        testval('[1,"2,3"]')
+        testval([1, 2, 3])
+        testval([1, '2,3'])
 
-        testval({ "key1" => [1,2,3], "keystr" => { "val" => "val"}})
+        testval('key1' => [1, 2, 3], 'keystr' => { 'val' => 'val' })
         testval(%Q({ "key1" : [1,2,3], "keystr" : { "val" : "val"}}))
 
-        testval("123456.1234")
-        testval("a string")
-        testval("\"a string\"")
+        testval('123456.1234')
+        testval('a string')
+        testval('"a string"')
       end
 
-      it "should return nil config value for non-existing key" do
-        expect(Marty::Config.lookup("TEST 2")).to eq(nil)
-        expect(Marty::Config["TEST 2"]).to eq(nil)
+      it 'should return nil config value for non-existing key' do
+        expect(Marty::Config.lookup('TEST 2')).to eq(nil)
+        expect(Marty::Config['TEST 2']).to eq(nil)
       end
 
-      it "should handle del" do
-        (0..10).each { |i|
-          v = {"i" => i}
+      it 'should handle del' do
+        (0..10).each do |i|
+          v = { 'i' => i }
           Marty::Config["k#{i}"] = v
           expect(Marty::Config["k#{i}"]).to eq(v)
-        }
+        end
 
-        (0..10).each { |i|
+        (0..10).each do |i|
           Marty::Config.del("k#{i}")
           expect(Marty::Config["k#{i}"]).to eq(nil)
-        }
+        end
       end
 
-      it "should allow the assignment of individual boolean values" do
+      it 'should allow the assignment of individual boolean values' do
         testval(true)
         testval(false)
       end
 
-      it "should not allow the assignment of individual nil (null) values" do
+      it 'should not allow the assignment of individual nil (null) values' do
         testval_fail(nil)
       end
 
-      it "should allow nil (null) to exist in other structures" do
+      it 'should allow nil (null) to exist in other structures' do
         testval([nil, 1, 2, nil])
-        testval({"key1"  => nil, "key2" => false, "key3" => 'val'})
+        testval('key1' => nil, 'key2' => false, 'key3' => 'val')
       end
     end
   end

data/spec/models/data_grid_spec.rb

@@ -2,8 +2,7 @@ require 'spec_helper'
 
 module Marty::DataGridSpec
   describe DataGrid do
-
-G1 =<<EOS
+G1 = <<EOS
 state\tstring\tv\t\t
 ltv\tnumrange\tv\t\t
 fico\tnumrange\th\t\t
@@ -16,7 +15,7 @@ MA\t>80<=105\t4.5\t5.6\t
 \t<=80\t11\t22\t33
 EOS
 
-G2 =<<EOS
+G2 = <<EOS
 units\tinteger\tv\t\t
 ltv\tnumrange\tv\t\t
 cltv\tnumrange\th\t\t
@@ -30,9 +29,9 @@ fico\tnumrange\th\t\t
 3|4\t>80<=105\t4.5\t5.6\t6.7
 EOS
 
-G3 = File.open(File.expand_path("../srp_data.csv", __FILE__)).read
+G3 = File.open(File.expand_path('../srp_data.csv', __FILE__)).read
 
-G4 =<<EOS
+G4 = <<EOS
 lenient
 hb_indicator\tboolean\tv
 cltv\tnumrange\th
@@ -41,21 +40,21 @@ cltv\tnumrange\th
 true\t-0.750\t-0.750\t-0.750\t-1.500\t-1.500\t-1.500\t\t
 EOS
 
-G5 =<<EOS
+G5 = <<EOS
 ltv\tnumrange\tv\t\t
 
 <=115\t-0.375
 >115<=135\t-0.750
 EOS
 
-G6 =<<EOS
+G6 = <<EOS
 ltv\tnumrange\th
 
 <=115\t>115<=135
 -0.375\t-0.750
 EOS
 
-G7 =<<EOS
+G7 = <<EOS
 string
 hb_indicator\tboolean\tv
 cltv\tnumrange\th
@@ -64,7 +63,7 @@ cltv\tnumrange\th
 true\tThis\tis\ta\ttest\tof\tstring type\t\t
 EOS
 
-G8 =<<EOS
+G8 = <<EOS
 Marty::DataGrid
 ltv\tnumrange\tv\t\t
 
@@ -73,7 +72,7 @@ ltv\tnumrange\tv\t\t
 >135<=140\tG3
 EOS
 
-G9 =<<EOS
+G9 = <<EOS
 state\tstring\tv
 ltv\tnumrange\tv
 
@@ -81,14 +80,14 @@ CA|TX\t>80\t123
 \t>80\t456
 EOS
 
-Ga =<<EOS
+Ga = <<EOS
 dg\tMarty::DataGrid\tv\t\t
 
 G1|G2\t7
 G3\t8
 EOS
 
-Gb =<<EOS
+Gb = <<EOS
 property_state\tGemini::State\tv\t\t
 
 CA|TX\t70
@@ -96,21 +95,21 @@ GA\t80
 MN\t90
 EOS
 
-Gc =<<EOS
+Gc = <<EOS
 Marty::DataGrid
 property_state\tGemini::State\tv\t\t
 
 CA|TX\tGb
 EOS
 
-Gd =<<EOS
+Gd = <<EOS
 hb_indicator\tboolean\tv
 
 true\t456
 false\t123
 EOS
 
-Ge =<<EOS
+Ge = <<EOS
 ltv\tnumrange\th
 
 >110\t>120
@@ -148,7 +147,7 @@ NY\t\t10
 \tR\t8
 EOS
 
-Gi =<<EOS
+Gi = <<EOS
 units\tinteger\tv\t\t
 ltv\tfloat\tv\t\t
 cltv\tfloat\th\t\t
@@ -162,7 +161,7 @@ fico\tnumrange\th\t\t
 3|4\t105.5\t4.5\t5.6\t6.7
 EOS
 
-Gj =<<EOS
+Gj = <<EOS
 lenient
 client_id\tinteger\tv
 property_state\tstring\tv
@@ -171,7 +170,7 @@ property_state\tstring\tv
 700127\tCA\t0.35
 EOS
 
-Gk =<<EOS
+Gk = <<EOS
 fha_203k_option\tstring\tv\tfha_203k_option
 
 Investor Services\t-0.625
@@ -180,657 +179,645 @@ Admin Services Plus\t-1.625
 Investor Services Acadamy\t-0.5
 EOS
 
-    before(:each) do
-      #Mcfly.whodunnit = Marty::User.find_by_login('marty')
-      marty_whodunnit
+before(:each) do
+  # Mcfly.whodunnit = Marty::User.find_by_login('marty')
+  marty_whodunnit
+end
+
+def lookup_grid_helper(pt, gridname, params, follow = false, distinct = true)
+  dgh = Marty::DataGrid.lookup_h(pt, gridname)
+  res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh, nil, follow,
+                                                     false, distinct)
+  [res['result'], res['name']]
+end
+
+describe 'imports' do
+  it 'should not allow imports with trailing blank columns' do
+    expect do
+      dg_from_import('G1', G1.gsub("\n", "\t\n"))
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'should not allow imports with last blank row' do
+    expect do
+      dg_from_import('Gh', Gh + "\t\t\n")
+    end.to raise_error(RuntimeError)
+  end
+end
+
+describe 'validations' do
+  it 'should not allow bad axis types' do
+    expect do
+      dg_from_import('Gi', Gi)
+    end.to raise_error(/unknown metadata type float/)
+    expect do
+      dg_from_import('Gi', Gi.sub(/float/, 'abcdef'))
+    end.to raise_error(/unknown metadata type abcdef/)
+  end
+
+  it 'should not allow dup attr names' do
+    g_bad = G1.sub(/fico/, 'ltv')
+
+    expect do
+      dg_from_import('G2', g_bad)
+    end.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it 'should not allow dup grid names' do
+    dg_from_import('G1', G1)
+
+    expect do
+      dg_from_import('G1', G2)
+    end.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it 'should not allow extra attr rows' do
+    g_bad = "x\tnumrange\th\t\t\n" + G1
+
+    expect do
+      dg_from_import('G2', g_bad)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'should not allow dup row/col key combos' do
+    g_bad = G1 + G1.split("\n").last + "\n"
+    expect do
+      dg_from_import('G2', g_bad)
+    end.to raise_error(ActiveRecord::RecordInvalid)
+
+    g_bad = G2 + G2.split("\n").last + "\n"
+    expect do
+      dg_from_import('G2', g_bad)
+    end.to raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it 'Unknown keys for typed grids should raise error' do
+    g_bad = G8.sub(/G3/, 'XXXXX')
+
+    expect do
+      dg_from_import('G8', g_bad)
+    end.to raise_error(RuntimeError)
+
+    g_bad = G8.sub(/DataGrid/, 'Division')
+
+    expect do
+      dg_from_import('G8', g_bad)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'Unknown keys for grid headers should raise error' do
+    g_bad = Ga.sub(/G3/, 'XXXXX')
+
+    expect do
+      dg_from_import('Ga', g_bad)
+    end.to raise_error(RuntimeError)
+
+    g_bad = Ga.sub(/DataGrid/, 'Division')
+
+    expect do
+      dg_from_import('Ga', g_bad)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'validates grid modifier' do
+    bad = ': abc def'
+    g_bad = Gk.sub(/fha_203k_option$/, bad)
+    expect do
+      dg_from_import('Gk', g_bad)
+    end.to raise_error(/invalid grid modifier expression: #{bad}/)
+    expect do
+      dg_from_import('Gk', Gk)
+    end.not_to raise_error
+  end
+end
+
+describe 'lookups for infinity' do
+  let(:pt) { 'infinity' }
+
+  before(:each) do
+    ['G1', 'G2', 'G3', 'G4', 'G5', 'G6', 'G7', 'G8', 'Ga', 'Gb',
+     'Gc', 'Gd', 'Ge', 'Gf', 'Gg', 'Gh', 'Gj'].each do |g|
+      dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
     end
+  end
+
+  context 'should handle NULL key values' do
+    let(:dgh) { 'Gf' }
 
-    def lookup_grid_helper(pt, gridname, params, follow=false, distinct=true)
-      dgh=Marty::DataGrid.lookup_h(pt, gridname)
-      res=Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh, nil, follow,
-                                                       false, distinct)
-      [res["result"], res["name"]]
+    it 'true returns Y' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'b' => true }, false)
+      expect(res).to eq('Y')
     end
 
-    describe "imports" do
-      it "should not allow imports with trailing blank columns" do
-        expect {
-          dg_from_import("G1", G1.gsub("\n", "\t\n"))
-        }.to raise_error(RuntimeError)
-      end
-
-      it "should not allow imports with last blank row" do
-        expect {
-          dg_from_import("Gh", Gh+"\t\t\n")
-        }.to raise_error(RuntimeError)
-      end
+    it '13 returns N' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13 }, true)
+      expect(res).to eq('N')
     end
 
-    describe "validations" do
-      it "should not allow bad axis types" do
-        expect {
-          dg_from_import("Gi", Gi)
-        }.to raise_error(/unknown metadata type float/)
-        expect {
-          dg_from_import("Gi", Gi.sub(/float/, 'abcdef'))
-        }.to raise_error(/unknown metadata type abcdef/)
-      end
-
-      it "should not allow dup attr names" do
-        g_bad = G1.sub(/fico/, "ltv")
-
-        expect {
-          dg_from_import("G2", g_bad)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-
-      it "should not allow dup grid names" do
-        dg_from_import("G1", G1)
-
-        expect {
-          dg_from_import("G1", G2)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-
-      it "should not allow extra attr rows" do
-        g_bad = "x\tnumrange\th\t\t\n" + G1
-
-        expect {
-          dg_from_import("G2", g_bad)
-        }.to raise_error(RuntimeError)
-      end
-
-      it "should not allow dup row/col key combos" do
-        g_bad = G1 + G1.split("\n").last + "\n"
-        expect {
-          dg_from_import("G2", g_bad)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-
-        g_bad = G2 + G2.split("\n").last + "\n"
-        expect {
-          dg_from_import("G2", g_bad)
-        }.to raise_error(ActiveRecord::RecordInvalid)
-      end
-
-      it "Unknown keys for typed grids should raise error" do
-        g_bad = G8.sub(/G3/, "XXXXX")
-
-        expect {
-          dg_from_import("G8", g_bad)
-        }.to raise_error(RuntimeError)
-
-        g_bad = G8.sub(/DataGrid/, "Division")
-
-        expect {
-          dg_from_import("G8", g_bad)
-        }.to raise_error(RuntimeError)
-      end
-
-      it "Unknown keys for grid headers should raise error" do
-        g_bad = Ga.sub(/G3/, "XXXXX")
-
-        expect {
-          dg_from_import("Ga", g_bad)
-        }.to raise_error(RuntimeError)
-
-        g_bad = Ga.sub(/DataGrid/, "Division")
-
-        expect {
-          dg_from_import("Ga", g_bad)
-        }.to raise_error(RuntimeError)
-      end
-
-      it "validates grid modifier" do
-        bad = ': abc def'
-        g_bad = Gk.sub(/fha_203k_option$/, bad)
-        expect { dg_from_import( "Gk", g_bad)
-        }.to raise_error(/invalid grid modifier expression: #{bad}/)
-        expect { dg_from_import( "Gk", Gk)
-        }.not_to raise_error
-      end
+    it '13 & numrange 0 returns nil' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 0 }, true)
+      expect(res).to eq('N')
     end
 
-    describe "lookups for infinity" do
-      let(:pt) { 'infinity'}
-
-      before(:each) do
-        ["G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "Ga", "Gb",
-         "Gc", "Gd", "Ge", "Gf", "Gg", "Gh", "Gj"].each { |g|
-          dg_from_import(g, "Marty::DataGridSpec::#{g}".constantize)
-        }
-      end
-
-      context "should handle NULL key values" do
-        let(:dgh) { "Gf" }
-
-        it 'true returns Y' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"b"=>true}, false)
-          expect(res).to eq('Y')
-        end
-
-        it '13 returns N' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13}, true)
-          expect(res).to eq('N')
-        end
-
-        it '13 & numrange 0 returns nil' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "n"=>0}, true)
-          expect(res).to eq('N')
-        end
-
-        it '13 & int4range 15 returns N' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "i4"=>15}, true)
-          expect(res).to eq('N')
-        end
-
-        it '13 & int4range 1 returns nil' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "i4"=>1}, true)
-          expect(res).to be_nil
-        end
-
-        it 'false, 3, numrange 15 returns N' do
-          res = Marty::DataGrid.
-                lookup_grid_h(pt, dgh, {"b"=>false, "i"=>3, "n"=>15}, true)
-          expect(res).to eq('N')
-        end
-
-        it '13, numrange 15 returns N' do
-          res = Marty::DataGrid.lookup_grid_h(pt, dgh, {"i"=>13, "n"=>15}, true)
-          expect(res).to eq('N')
-        end
-      end
-
-      it "should handle ambiguous lookups" do
-        h1 = {
-          "property_state" => "NY",
-          "county_name"    => "R",
-        }
-
-        res = Marty::DataGrid.lookup_grid_h(pt, "Gh", h1, false)
-        expect(res).to eq(10)
-      end
-
-      it "should handle ambiguous lookups (2)" do
-        res = Marty::DataGrid.
-              lookup_grid_h(pt, "Gg", {"i1"=>2, "i2"=>1}, false)
-        expect(res).to eq(1)
-
-        res = Marty::DataGrid.
-              lookup_grid_h(pt, "Gg", {"i1"=>3, "i2"=>1}, false)
-        expect(res).to eq(1)
-
-        res = Marty::DataGrid.
-              lookup_grid_h(pt, "Gg", {"i1"=>2, "i2"=>3}, false)
-        expect(res).to eq(20)
-      end
-
-      it "should handle non-distinct lookups" do
-        res = Marty::DataGrid.lookup_grid_h(pt, "Ge", {"ltv"=>500}, false)
-
-        expect(res).to eq(1.1)
-
-        expect {
-          Marty::DataGrid.lookup_grid_h(pt, "Ge", {"ltv"=>500}, true)
-        }.to raise_error(RuntimeError)
-      end
-
-      it "should handle non-distinct lookups (2)" do
-        params = {
-          "client_id" => 700127,
-          "property_state" => "CA",
-        }
-        res = Marty::DataGrid.lookup_grid_h(pt, "Gj", params, false)
-
-        # should return the upper left corner match
-        expect(res).to eq(0.25)
-
-        expect {
-          Marty::DataGrid.lookup_grid_h(pt, "Gj", params, true)
-        }.to raise_error(RuntimeError)
-      end
-
-      it "should handle boolean lookups" do
-        res = [true, false].map { |hb_indicator|
-          lookup_grid_helper('infinity',
-                             "Gd",
-                             {"hb_indicator" => hb_indicator,
-                             },
-                            )
-        }
-        expect(res).to eq [[456.0, "Gd"], [123.0, "Gd"]]
-      end
-
-      it "should handle basic lookups" do
-        res = lookup_grid_helper('infinity',
-                                 "G3",
-                                 {"amount" => 160300,
-                                  "state" => "HI",
-                                 },
-                                )
-        expect(res).to eq [1.655,"G3"]
-
-        [3,4].each {
-          |units|
-          res = lookup_grid_helper('infinity',
-                                   "G2",
-                                   {"fico" => 720,
-                                    "units" => units,
-                                    "ltv" => 100,
-                                    "cltv" => 110.1,
-                                   },
-                                  )
-          expect(res).to eq [5.6,"G2"]
-        }
-
-        dg = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
-
-        h = {
-          "fico" => 600,
-          "state" => "RI",
-          "ltv" => 10,
-        }
-
-        res = lookup_grid_helper('infinity', "G1", h)
-        expect(res).to eq [11,"G1"]
-
-        dg.update_from_import("G1", G1.sub(/11/, "111"))
-
-        res = lookup_grid_helper('infinity', "G1", h)
-        expect(res).to eq [111,"G1"]
-      end
-
-      it "should result in error when there are multiple cell hits" do
-        expect {
-          lookup_grid_helper('infinity',
-                             "G2",
-                             {"fico" => 720,
-                              "ltv" => 100,
-                              "cltv" => 110.1,
-                             },
+    it '13 & int4range 15 returns N' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 15 }, true)
+      expect(res).to eq('N')
+    end
+
+    it '13 & int4range 1 returns nil' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'i4' => 1 }, true)
+      expect(res).to be_nil
+    end
+
+    it 'false, 3, numrange 15 returns N' do
+      res = Marty::DataGrid.
+            lookup_grid_h(pt, dgh, { 'b' => false, 'i' => 3, 'n' => 15 }, true)
+      expect(res).to eq('N')
+    end
+
+    it '13, numrange 15 returns N' do
+      res = Marty::DataGrid.lookup_grid_h(pt, dgh, { 'i' => 13, 'n' => 15 }, true)
+      expect(res).to eq('N')
+    end
+  end
+
+  it 'should handle ambiguous lookups' do
+    h1 = {
+      'property_state' => 'NY',
+      'county_name'    => 'R',
+    }
+
+    res = Marty::DataGrid.lookup_grid_h(pt, 'Gh', h1, false)
+    expect(res).to eq(10)
+  end
+
+  it 'should handle ambiguous lookups (2)' do
+    res = Marty::DataGrid.
+          lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 1 }, false)
+    expect(res).to eq(1)
+
+    res = Marty::DataGrid.
+          lookup_grid_h(pt, 'Gg', { 'i1' => 3, 'i2' => 1 }, false)
+    expect(res).to eq(1)
+
+    res = Marty::DataGrid.
+          lookup_grid_h(pt, 'Gg', { 'i1' => 2, 'i2' => 3 }, false)
+    expect(res).to eq(20)
+  end
+
+  it 'should handle non-distinct lookups' do
+    res = Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, false)
+
+    expect(res).to eq(1.1)
+
+    expect do
+      Marty::DataGrid.lookup_grid_h(pt, 'Ge', { 'ltv' => 500 }, true)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'should handle non-distinct lookups (2)' do
+    params = {
+      'client_id' => 700127,
+      'property_state' => 'CA',
+    }
+    res = Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, false)
+
+    # should return the upper left corner match
+    expect(res).to eq(0.25)
+
+    expect do
+      Marty::DataGrid.lookup_grid_h(pt, 'Gj', params, true)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'should handle boolean lookups' do
+    res = [true, false].map do |hb_indicator|
+      lookup_grid_helper('infinity',
+                         'Gd',
+                         'hb_indicator' => hb_indicator,
+                        )
+    end
+    expect(res).to eq [[456.0, 'Gd'], [123.0, 'Gd']]
+  end
+
+  it 'should handle basic lookups' do
+    res = lookup_grid_helper('infinity',
+                             'G3',
+                             'amount' => 160300,
+                             'state' => 'HI',
                             )
-        }.to raise_error(RuntimeError)
-      end
-
-      it "should return nil when matching data grid cell is nil" do
-        res = lookup_grid_helper('infinity',
-                                 "G1",
-                                 {"fico" => 800,
-                                  "state" => "MA",
-                                  "ltv" => 81,
-                                 },
-                                )
-        expect(res).to eq [nil,"G1"]
-      end
-
-      it "should handle string wildcards" do
-        res = lookup_grid_helper('infinity',
-                                 "G1",
-                                 {"fico" => 720,
-                                  "state" => "GU",
-                                  "ltv" => 80,
-                                 },
-                                )
-        expect(res).to eq [22,"G1"]
-      end
-
-      it "should handle matches which also have a wildcard match" do
-        dg_from_import("G9", G9)
-
-        expect {
-          res = lookup_grid_helper('infinity',
-                                   "G9",
-                                   {"state" => "CA", "ltv" => 81},
-                                  )
-        }.to raise_error(RuntimeError)
-
-        res = lookup_grid_helper('infinity',
-                                 "G9",
-                                 {"state" => "GU", "ltv" => 81},
-                                )
-        expect(res).to eq [456,"G9"]
-      end
-
-      it "should raise on nil attr values" do
-        dg_from_import("G9", G9)
-
-        expect{lookup_grid_helper('infinity',
-                               "G9",
-                               {"ltv" => 81},
-                               )}.to raise_error(/matches > 1/)
-
-        err = /Data Grid lookup failed/
-        expect{lookup_grid_helper('infinity',
-                                 "G9",
-                                 {"state" => "CA", "ltv" => nil},
-                                 false, false)}.to raise_error(err)
-
-        res = lookup_grid_helper('infinity',
-                                 "G9",
-                                 {"state" => nil, "ltv" => 81},
-                                 false, false)
-
-        expect(res).to eq [456,"G9"]
-      end
-
-      it "should handle boolean keys" do
-        res = lookup_grid_helper('infinity',
-                                 "G4",
-                                 {"hb_indicator" => true,
-                                  "cltv" => 80,
-                                 },
-                                )
-        expect(res).to eq [-1.5,"G4"]
-
-        res = lookup_grid_helper('infinity',
-                                 "G4",
-                                 {"hb_indicator" => false,
-                                  "cltv" => 80,
-                                 },
-                                )
-        expect(res).to eq [nil,"G4"]
-      end
-
-      it "should handle vertical-only grids" do
-        res = lookup_grid_helper('infinity',
-                                 "G5",
-                                 {"ltv" => 80},
-                                )
-        expect(res).to eq [-0.375,"G5"]
-      end
-
-      it "should handle horiz-only grids" do
-        res = lookup_grid_helper('infinity',
-                                 "G6",
-                                 {"ltv" => 80, "conforming" => true},
-                                )
-        expect(res).to eq [-0.375,"G6"]
-      end
-
-      it "should handle string typed data grids" do
-        expect(Marty::DataGrid.lookup('infinity', "G7").data_type).to eq "string"
-
-        res = lookup_grid_helper('infinity',
-                                 "G7",
-                                 {"hb_indicator" => true,
-                                  "cltv" => 80,
-                                 },
-                                )
-        expect(res).to eq ["test","G7"]
-      end
-
-      it "should handle DataGrid typed data grids" do
-        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
-          to eq "Marty::DataGrid"
-        g1 = Marty::DataGrid.lookup('infinity', "G1")
-
-        res = lookup_grid_helper('infinity',
-                                 "G8",
-                                 {"ltv" => 80,
-                                 },
-                                )
-        expect(res).to eq [g1,"G8"]
-      end
-
-      it "should handle multi DataGrid lookups" do
-        expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
-          to eq "Marty::DataGrid"
-
-        h = {
-          "fico" => 600,
-          "state" => "RI",
-          "ltv" => 10,
-        }
-
-        g1_res = lookup_grid_helper('infinity', "G1", h)
-        expect(g1_res).to eq [11,"G1"]
-
-        res = lookup_grid_helper('infinity',
-                                       "G8",
-                                       h,true
-                                      )
-        expect(g1_res).to eq res
-      end
-
-      it "should handle DataGrid typed data grids" do
-        g1 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
-
-        res = lookup_grid_helper('infinity',
-                                 "Ga",
-                                 {"dg" => g1,
-                                 },
-                                )
-        expect(res).to eq [7,"Ga"]
-
-        # should be able to lookup bu name as well
-        res = lookup_grid_helper('infinity',
-                                 "Ga",
-                                 {"dg" => "G2",
-                                 },
-                                )
-        expect(res).to eq [7,"Ga"]
-      end
-
-      it "should handle DataGrid typed data grids -- non mcfly" do
-        ca = Gemini::State.find_by_name("CA")
-
-        res = lookup_grid_helper('infinity',
-                                 "Gb",
-                                 {"property_state" => ca,
-                                 },
-                                )
-        expect(res).to eq [70,"Gb"]
-
-        # should be able to lookup bu name as well
-        res = lookup_grid_helper('infinity',
-                                 "Gb",
-                                 {"property_state" => "CA",
-                                 },
-                                )
-        expect(res).to eq [70,"Gb"]
-      end
-
-      it "should handle typed (enum) data lookup_grid" do
-        pt = 'infinity'
-        ca = Gemini::State.find_by_name("CA")
-
-        res = Marty::DataGrid.
-              lookup_grid_h(pt, "Gb", {"property_state" => ca}, false)
-
-        expect(res).to eq 70
-      end
-
-      it "should return grid data and metadata simple" do
-        expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
-                         [4.5, 5.6, 6.7]]
-        expected_metadata = [{"dir"=>"v",
-                              "attr"=>"units",
-                              "keys"=>[[1, 2], [1, 2], [3, 4], [3, 4]],
-                              "type"=>"integer"},
-                             {"dir"=>"v",
-                              "attr"=>"ltv",
-                              "keys"=>["[,80]", "(80,105]", "[,80]", "(80,105]"],
-                              "type"=>"numrange"},
-                             {"dir"=>"h",
-                              "attr"=>"cltv",
-                              "keys"=>["[100,110)", "[110,120)", "[120,]"],
-                              "type"=>"numrange"},
-                             {"dir"=>"h",
-                              "attr"=>"fico",
-                              "keys"=>["[600,700)", "[700,750)", "[750,]"],
-                              "type"=>"numrange"}]
-
-        dgh = Marty::DataGrid.lookup_h(pt, 'G2')
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, {}, dgh,
-                                                           nil, true, true)
-        expect(res["data"]).to eq (expected_data)
-        expect(res["metadata"]).to eq (expected_metadata)
-      end
-
-      it "should return grid data and metadata multi (following)" do
-        expected_data =  [[1.1, 2.2, 3.3],[4.4, 5.5, 6.6],[1.2, 2.3, 3.4],
-                          [4.5, 5.6, nil],[11.0, 22.0, 33.0]]
-        expected_metadata = [{"dir"=>"v",
-                              "attr"=>"state",
-                              "keys"=>[["CA"], ["HI", "TX"], ["NM"], ["MA"], nil],
-                              "type"=>"string"},
-                             {"dir"=>"v",
-                              "attr"=>"ltv",
-                              "keys"=>["[,80]", "(80,105]", "[,80]", "(80,105]",
-                                       "[,80]"],
-                              "type"=>"numrange"},
-                             {"dir"=>"h",
-                              "attr"=>"fico",
-                              "keys"=>["[600,700)", "[700,750)", "[750,]"],
-                              "type"=>"numrange"}]
-        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                           { "ltv" => 10,
-                                                             "state" => "RI" },
-                                                           dgh, nil, true,
-                                            true)
-        expect(res["data"]).to eq (expected_data)
-        expect(res["metadata"]).to eq (expected_metadata)
-      end
-
-      it "should return grid data and metadata multi (not following)" do
-        expected_data = [["G1"], ["G2"], ["G3"]]
-        expected_metadata = [{"dir"=>"v",
-                              "attr"=>"ltv",
-                              "keys"=>["[,115]", "(115,135]", "(135,140]"],
-                              "type"=>"numrange"}]
-        dgh = Marty::DataGrid.lookup_h(pt, 'G8')
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                           { "ltv" => 10,
-                                                             "state" => "RI" },
-                                                           dgh, nil, false,
-                                            true)
-        expect(res["data"]).to eq (expected_data)
-        expect(res["metadata"]).to eq (expected_metadata)
-      end
-
-      it "should handle all characters in grid inputs" do
-        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-        5000.times do
-          st = 30.times.map{rand(224)+32}.pack('U*')
-          res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
-                                                             { "ltv" => 10,
-                                                               "fico" => 690,
-                                                               "state" => st },
-                                                             dgh, nil, false, true)
-        end
-      end
-      it "should handle all quote chars in grid inputs" do
-        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-        # single, double, backslash, grave, acute, unicode quotes: left single,
-        # right single, left double, right double
-        quotes = ["'", '"', '\\', '`', "\u00b4", "\u2018", "\u2019",
-                  "\u201C", "\u201D"]
-        100.times do
-          st = 30.times.map{quotes[rand(9)]}.join
-          res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-            pt, {"ltv" => 10, "fico" => 690, "state" => st}, dgh, nil, false, true)
-        end
-      end
-      it "should handle quote chars in object name" do
-        dgh = Marty::DataGrid.lookup_h(pt, 'G1')
-        st = Gemini::State.new(name: "'\\")
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
-          pt, {"ltv" => 10, "fico" => 690, "state" => st}, dgh, nil, false, true)
-      end
+    expect(res).to eq [1.655, 'G3']
+
+    [3, 4].each do |units|
+      res = lookup_grid_helper('infinity',
+                               'G2',
+                               'fico' => 720,
+                               'units' => units,
+                               'ltv' => 100,
+                               'cltv' => 110.1,
+                              )
+      expect(res).to eq [5.6, 'G2']
     end
 
-    describe "exports" do
-      it 'should export lenient grids correctly' do
-        dg = dg_from_import("Gf", Gf)
-        dg2 = dg_from_import("Gf2", dg.export)
+    dg = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+
+    h = {
+      'fico' => 600,
+      'state' => 'RI',
+      'ltv' => 10,
+    }
 
-        expect(dg.export).to eq(dg2.export)
-      end
+    res = lookup_grid_helper('infinity', 'G1', h)
+    expect(res).to eq [11, 'G1']
+
+    dg.update_from_import('G1', G1.sub(/11/, '111'))
+
+    res = lookup_grid_helper('infinity', 'G1', h)
+    expect(res).to eq [111, 'G1']
+  end
+
+  it 'should result in error when there are multiple cell hits' do
+    expect do
+      lookup_grid_helper('infinity',
+                         'G2',
+                         'fico' => 720,
+                         'ltv' => 100,
+                         'cltv' => 110.1,
+                        )
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'should return nil when matching data grid cell is nil' do
+    res = lookup_grid_helper('infinity',
+                             'G1',
+                             'fico' => 800,
+                             'state' => 'MA',
+                             'ltv' => 81,
+                            )
+    expect(res).to eq [nil, 'G1']
+  end
+
+  it 'should handle string wildcards' do
+    res = lookup_grid_helper('infinity',
+                             'G1',
+                             'fico' => 720,
+                             'state' => 'GU',
+                             'ltv' => 80,
+                            )
+    expect(res).to eq [22, 'G1']
+  end
+
+  it 'should handle matches which also have a wildcard match' do
+    dg_from_import('G9', G9)
+
+    expect do
+      res = lookup_grid_helper('infinity',
+                               'G9',
+                               'state' => 'CA', 'ltv' => 81,
+                              )
+    end.to raise_error(RuntimeError)
+
+    res = lookup_grid_helper('infinity',
+                             'G9',
+                             'state' => 'GU', 'ltv' => 81,
+                            )
+    expect(res).to eq [456, 'G9']
+  end
+
+  it 'should raise on nil attr values' do
+    dg_from_import('G9', G9)
+
+    expect do
+      lookup_grid_helper('infinity',
+                         'G9',
+                         'ltv' => 81,
+                        )
+    end        .to raise_error(/matches > 1/)
+
+    err = /Data Grid lookup failed/
+    expect do
+      lookup_grid_helper('infinity',
+                         'G9',
+                         { 'state' => 'CA', 'ltv' => nil },
+                         false, false)
+    end        .to raise_error(err)
+
+    res = lookup_grid_helper('infinity',
+                             'G9',
+                             { 'state' => nil, 'ltv' => 81 },
+                             false, false)
+
+    expect(res).to eq [456, 'G9']
+  end
+
+  it 'should handle boolean keys' do
+    res = lookup_grid_helper('infinity',
+                             'G4',
+                             'hb_indicator' => true,
+                             'cltv' => 80,
+                            )
+    expect(res).to eq [-1.5, 'G4']
+
+    res = lookup_grid_helper('infinity',
+                             'G4',
+                             'hb_indicator' => false,
+                             'cltv' => 80,
+                            )
+    expect(res).to eq [nil, 'G4']
+  end
+
+  it 'should handle vertical-only grids' do
+    res = lookup_grid_helper('infinity',
+                             'G5',
+                             'ltv' => 80,
+                            )
+    expect(res).to eq [-0.375, 'G5']
+  end
+
+  it 'should handle horiz-only grids' do
+    res = lookup_grid_helper('infinity',
+                             'G6',
+                             'ltv' => 80, 'conforming' => true,
+                            )
+    expect(res).to eq [-0.375, 'G6']
+  end
+
+  it 'should handle string typed data grids' do
+    expect(Marty::DataGrid.lookup('infinity', 'G7').data_type).to eq 'string'
+
+    res = lookup_grid_helper('infinity',
+                             'G7',
+                             'hb_indicator' => true,
+                             'cltv' => 80,
+                            )
+    expect(res).to eq ['test', 'G7']
+  end
+
+  it 'should handle DataGrid typed data grids' do
+    expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
+      to eq 'Marty::DataGrid'
+    g1 = Marty::DataGrid.lookup('infinity', 'G1')
+
+    res = lookup_grid_helper('infinity',
+                             'G8',
+                             'ltv' => 80,
+                            )
+    expect(res).to eq [g1, 'G8']
+  end
+
+  it 'should handle multi DataGrid lookups' do
+    expect(Marty::DataGrid.lookup('infinity', 'G8').data_type).
+      to eq 'Marty::DataGrid'
+
+    h = {
+      'fico' => 600,
+      'state' => 'RI',
+      'ltv' => 10,
+    }
+
+    g1_res = lookup_grid_helper('infinity', 'G1', h)
+    expect(g1_res).to eq [11, 'G1']
+
+    res = lookup_grid_helper('infinity',
+                             'G8',
+                             h, true
+                           )
+    expect(g1_res).to eq res
+  end
+
+  it 'should handle DataGrid typed data grids' do
+    g1 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+
+    res = lookup_grid_helper('infinity',
+                             'Ga',
+                             'dg' => g1,
+                            )
+    expect(res).to eq [7, 'Ga']
+
+    # should be able to lookup bu name as well
+    res = lookup_grid_helper('infinity',
+                             'Ga',
+                             'dg' => 'G2',
+                            )
+    expect(res).to eq [7, 'Ga']
+  end
+
+  it 'should handle DataGrid typed data grids -- non mcfly' do
+    ca = Gemini::State.find_by_name('CA')
+
+    res = lookup_grid_helper('infinity',
+                             'Gb',
+                             'property_state' => ca,
+                            )
+    expect(res).to eq [70, 'Gb']
+
+    # should be able to lookup bu name as well
+    res = lookup_grid_helper('infinity',
+                             'Gb',
+                             'property_state' => 'CA',
+                            )
+    expect(res).to eq [70, 'Gb']
+  end
+
+  it 'should handle typed (enum) data lookup_grid' do
+    pt = 'infinity'
+    ca = Gemini::State.find_by_name('CA')
+
+    res = Marty::DataGrid.
+          lookup_grid_h(pt, 'Gb', { 'property_state' => ca }, false)
+
+    expect(res).to eq 70
+  end
+
+  it 'should return grid data and metadata simple' do
+    expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
+                     [4.5, 5.6, 6.7]]
+    expected_metadata = [{ 'dir' => 'v',
+                          'attr' => 'units',
+                          'keys' => [[1, 2], [1, 2], [3, 4], [3, 4]],
+                          'type' => 'integer' },
+                         { 'dir' => 'v',
+                          'attr' => 'ltv',
+                          'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]'],
+                          'type' => 'numrange' },
+                         { 'dir' => 'h',
+                          'attr' => 'cltv',
+                          'keys' => ['[100,110)', '[110,120)', '[120,]'],
+                          'type' => 'numrange' },
+                         { 'dir' => 'h',
+                          'attr' => 'fico',
+                          'keys' => ['[600,700)', '[700,750)', '[750,]'],
+                          'type' => 'numrange' }]
+
+    dgh = Marty::DataGrid.lookup_h(pt, 'G2')
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, {}, dgh,
+                                                       nil, true, true)
+    expect(res['data']).to eq expected_data
+    expect(res['metadata']).to eq expected_metadata
+  end
+
+  it 'should return grid data and metadata multi (following)' do
+    expected_data = [[1.1, 2.2, 3.3], [4.4, 5.5, 6.6], [1.2, 2.3, 3.4],
+                     [4.5, 5.6, nil], [11.0, 22.0, 33.0]]
+    expected_metadata = [{ 'dir' => 'v',
+                          'attr' => 'state',
+                          'keys' => [['CA'], ['HI', 'TX'], ['NM'], ['MA'], nil],
+                          'type' => 'string' },
+                         { 'dir' => 'v',
+                          'attr' => 'ltv',
+                          'keys' => ['[,80]', '(80,105]', '[,80]', '(80,105]',
+                                     '[,80]'],
+                          'type' => 'numrange' },
+                         { 'dir' => 'h',
+                          'attr' => 'fico',
+                          'keys' => ['[600,700)', '[700,750)', '[750,]'],
+                          'type' => 'numrange' }]
+    dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                       { 'ltv' => 10,
+                                                         'state' => 'RI' },
+                                                       dgh, nil, true,
+                                                       true)
+    expect(res['data']).to eq expected_data
+    expect(res['metadata']).to eq expected_metadata
+  end
+
+  it 'should return grid data and metadata multi (not following)' do
+    expected_data = [['G1'], ['G2'], ['G3']]
+    expected_metadata = [{ 'dir' => 'v',
+                          'attr' => 'ltv',
+                          'keys' => ['[,115]', '(115,135]', '(135,140]'],
+                          'type' => 'numrange' }]
+    dgh = Marty::DataGrid.lookup_h(pt, 'G8')
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                       { 'ltv' => 10,
+                                                         'state' => 'RI' },
+                                                       dgh, nil, false,
+                                                       true)
+    expect(res['data']).to eq expected_data
+    expect(res['metadata']).to eq expected_metadata
+  end
+
+  it 'should handle all characters in grid inputs' do
+    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+    5000.times do
+      st = 30.times.map { rand(32..255) }.pack('U*')
+      res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt,
+                                                         { 'ltv' => 10,
+                                                           'fico' => 690,
+                                                           'state' => st },
+                                                         dgh, nil, false, true)
     end
+  end
+  it 'should handle all quote chars in grid inputs' do
+    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+    # single, double, backslash, grave, acute, unicode quotes: left single,
+    # right single, left double, right double
+    quotes = ["'", '"', '\\', '`', "\u00b4", "\u2018", "\u2019",
+              "\u201C", "\u201D"]
+    100.times do
+      st = 30.times.map { quotes[rand(9)] }.join
+      res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+        pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
+    end
+  end
+  it 'should handle quote chars in object name' do
+    dgh = Marty::DataGrid.lookup_h(pt, 'G1')
+    st = Gemini::State.new(name: "'\\")
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+      pt, { 'ltv' => 10, 'fico' => 690, 'state' => st }, dgh, nil, false, true)
+  end
+end
+
+describe 'exports' do
+  it 'should export lenient grids correctly' do
+    dg = dg_from_import('Gf', Gf)
+    dg2 = dg_from_import('Gf2', dg.export)
+
+    expect(dg.export).to eq(dg2.export)
+  end
+end
+
+describe 'updates' do
+  it 'should be possible to modify a grid referenced from a multi-grid' do
+    dgb = dg_from_import('Gb', Gb, '1/1/2014')
+    dgc = dg_from_import('Gc', Gc, '2/2/2014')
+
+    dgb.update_from_import('Gb', Gb.sub(/70/, '333'), '1/1/2015')
+    dgb.update_from_import('Gb', Gb.sub(/70/, '444'), '1/1/2016')
+
+    dgch = dgc.attributes.
+           slice('id', 'group_id', 'created_dt',  'metadata', 'data_type')
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2014',
+                                                       { 'property_state' => 'CA' }, dgch)
+    expect(res['result']).to eq(70)
+
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2015',
+                                                       { 'property_state' => 'CA' }, dgch)
 
-    describe "updates" do
-      it "should be possible to modify a grid referenced from a multi-grid" do
-        dgb = dg_from_import("Gb", Gb, '1/1/2014')
-        dgc = dg_from_import("Gc", Gc, '2/2/2014')
-
-        dgb.update_from_import("Gb", Gb.sub(/70/, "333"), '1/1/2015')
-        dgb.update_from_import("Gb", Gb.sub(/70/, "444"), '1/1/2016')
-
-        dgch = dgc.attributes.
-               slice("id","group_id","created_dt",  "metadata", "data_type")
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2014',
-                                             {"property_state" => "CA"}, dgch)
-        expect(res["result"]).to eq(70)
-
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2015',
-                                             {"property_state" => "CA"}, dgch)
-
-        expect(res["result"]).to eq(333)
-
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2016',
-                                             {"property_state" => "CA"}, dgch)
-
-        expect(res["result"]).to eq(444)
-      end
-
-      it "should not create a new version if no change has been made" do
-        dg = dg_from_import("G4", G1)
-        dg.update_from_import("G4", G1)
-        expect(Marty::DataGrid.where(group_id: dg.group_id).count).to eq 1
-      end
-
-      it "should be able to export and import back grids" do
-        [G1, G2, G3, G4, G5, G6, G7, G8, G9, Ga, Gb].each_with_index do
-          |grid, i|
-          dg = dg_from_import("G#{i}", grid)
-          g1 = dg.export
-          dg = dg_from_import("Gx#{i}", g1)
-          g2 = dg.export
-          expect(g1).to eq g2
-        end
-      end
-
-      it "should be able to externally export/import grids" do
-        load_scripts(nil, Date.today)
-
-        dg = dg_from_import("G1", G1)
-
-        p = posting("BASE", DateTime.tomorrow, '?')
-
-        engine = Marty::ScriptSet.new.get_engine("DataReport")
-        res = engine.evaluate("TableReport",
-                              "result",
-                              {
-                                "pt_name"    => p.name,
-                                "class_name" => "Marty::DataGrid",
-                              },
-                             )
-
-        # FIXME: really hacky removing "" (data_grid) -- This is a bug
-        # in TableReport/CSV generation.
-        res.gsub!(/\"\"/, '')
-        sum = do_import_summary(Marty::DataGrid,
-                                res,
-                                'infinity',
-                                nil,
-                                nil,
-                                ",",
-                               )
-
-        expect(sum).to eq({same: 1})
-
-        res11 = res.sub(/G1/, "G11")
-
-        sum = do_import_summary(
-          Marty::DataGrid, res11, 'infinity', nil, nil, ",")
-
-        expect(sum).to eq({create: 1})
-
-        g1  = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
-        g11 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G11")
-
-        expect(g1.export).to eq g11.export
-      end
+    expect(res['result']).to eq(333)
+
+    res = Marty::DataGrid.lookup_grid_distinct_entry_h('2/2/2016',
+                                                       { 'property_state' => 'CA' }, dgch)
+
+    expect(res['result']).to eq(444)
+  end
+
+  it 'should not create a new version if no change has been made' do
+    dg = dg_from_import('G4', G1)
+    dg.update_from_import('G4', G1)
+    expect(Marty::DataGrid.where(group_id: dg.group_id).count).to eq 1
+  end
+
+  it 'should be able to export and import back grids' do
+    [G1, G2, G3, G4, G5, G6, G7, G8, G9, Ga, Gb].each_with_index do |grid, i|
+      dg = dg_from_import("G#{i}", grid)
+      g1 = dg.export
+      dg = dg_from_import("Gx#{i}", g1)
+      g2 = dg.export
+      expect(g1).to eq g2
     end
   end
+
+  it 'should be able to externally export/import grids' do
+    load_scripts(nil, Date.today)
+
+    dg = dg_from_import('G1', G1)
+
+    p = posting('BASE', DateTime.tomorrow, '?')
+
+    engine = Marty::ScriptSet.new.get_engine('DataReport')
+    res = engine.evaluate('TableReport',
+                          'result',
+                          'pt_name'    => p.name,
+                          'class_name' => 'Marty::DataGrid',
+                         )
+
+    # FIXME: really hacky removing "" (data_grid) -- This is a bug
+    # in TableReport/CSV generation.
+    res.gsub!(/\"\"/, '')
+    sum = do_import_summary(Marty::DataGrid,
+                            res,
+                            'infinity',
+                            nil,
+                            nil,
+                            ',',
+                           )
+
+    expect(sum).to eq(same: 1)
+
+    res11 = res.sub(/G1/, 'G11')
+
+    sum = do_import_summary(
+      Marty::DataGrid, res11, 'infinity', nil, nil, ',')
+
+    expect(sum).to eq(create: 1)
+
+    g1  = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G1')
+    g11 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: 'G11')
+
+    expect(g1.export).to eq g11.export
+  end
+end
+  end
 end